drivers/usb/wusbcore/wa-rpipe.c

   1 /*
   2  * WUSB Wire Adapter
   3  * rpipe management
   4  *
   5  * Copyright (C) 2005-2006 Intel Corporation
   6  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License version
  10  * 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20  * 02110-1301, USA.
  21  *
  22  *
  23  * FIXME: docs
  24  *
  25  * RPIPE
  26  *
  27  *   Targeted at different downstream endpoints
  28  *
  29  *   Descriptor: use to config the remote pipe.
  30  *
  31  *   The number of blocks could be dynamic (wBlocks in descriptor is
  32  *   0)--need to schedule them then.
  33  *
  34  * Each bit in wa->rpipe_bm represents if an rpipe is being used or
  35  * not. Rpipes are represented with a 'struct wa_rpipe' that is
  36  * attached to the hcpriv member of a 'struct usb_host_endpoint'.
  37  *
  38  * When you need to xfer data to an endpoint, you get an rpipe for it
  39  * with wa_ep_rpipe_get(), which gives you a reference to the rpipe
  40  * and keeps a single one (the first one) with the endpoint. When you
  41  * are done transferring, you drop that reference. At the end the
  42  * rpipe is always allocated and bound to the endpoint. There it might
  43  * be recycled when not used.
  44  *
  45  * Addresses:
  46  *
  47  *  We use a 1:1 mapping mechanism between port address (0 based
  48  *  index, actually) and the address. The USB stack knows about this.
  49  *
  50  *  USB Stack port number    4 (1 based)
  51  *  WUSB code port index     3 (0 based)
  52  *  USB Address             5 (2 based -- 0 is for default, 1 for root hub)
  53  *
  54  *  Now, because we don't use the concept as default address exactly
  55  *  like the (wired) USB code does, we need to kind of skip it. So we
  56  *  never take addresses from the urb->pipe, but from the
  57  *  urb->dev->devnum, to make sure that we always have the right
  58  *  destination address.
  59  */
  60 #include <linux/init.h>
  61 #include <linux/atomic.h>
  62 #include <linux/bitmap.h>
  63 #include <linux/slab.h>
  64 #include <linux/export.h>
  65
  66 #include "wusbhc.h"
  67 #include "wa-hc.h"
  68
  69 static int __rpipe_get_descr(struct wahc *wa,
  70                              struct usb_rpipe_descriptor *descr, u16 index)
  71 {
  72         ssize_t result;
  73         struct device *dev = &wa->usb_iface->dev;
  74
  75         /* Get the RPIPE descriptor -- we cannot use the usb_get_descriptor()
  76          * function because the arguments are different.
  77          */
  78         result = usb_control_msg(
  79                 wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
  80                 USB_REQ_GET_DESCRIPTOR,
  81                 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_RPIPE,
  82                 USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
  83                 USB_CTRL_GET_TIMEOUT);
  84         if (result < 0) {
  85                 dev_err(dev, "rpipe %u: get descriptor failed: %d\n",
  86                         index, (int)result);
  87                 goto error;
  88         }
  89         if (result < sizeof(*descr)) {
  90                 dev_err(dev, "rpipe %u: got short descriptor "
  91                         "(%zd vs %zd bytes needed)\n",
  92                         index, result, sizeof(*descr));
  93                 result = -EINVAL;
  94                 goto error;
  95         }
  96         result = 0;
  97
  98 error:
  99         return result;
 100 }
 101
 102 /*
 103  *
 104  * The descriptor is assumed to be properly initialized (ie: you got
 105  * it through __rpipe_get_descr()).
 106  */
 107 static int __rpipe_set_descr(struct wahc *wa,
 108                              struct usb_rpipe_descriptor *descr, u16 index)
 109 {
 110         ssize_t result;
 111         struct device *dev = &wa->usb_iface->dev;
 112
 113         /* we cannot use the usb_get_descriptor() function because the
 114          * arguments are different.
 115          */
 116         result = usb_control_msg(
 117                 wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
 118                 USB_REQ_SET_DESCRIPTOR,
 119                 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
 120                 USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
 121                 USB_CTRL_SET_TIMEOUT);
 122         if (result < 0) {
 123                 dev_err(dev, "rpipe %u: set descriptor failed: %d\n",
 124                         index, (int)result);
 125                 goto error;
 126         }
 127         if (result < sizeof(*descr)) {
 128                 dev_err(dev, "rpipe %u: sent short descriptor "
 129                         "(%zd vs %zd bytes required)\n",
 130                         index, result, sizeof(*descr));
 131                 result = -EINVAL;
 132                 goto error;
 133         }
 134         result = 0;
 135
 136 error:
 137         return result;
 138
 139 }
 140
 141 static void rpipe_init(struct wa_rpipe *rpipe)
 142 {
 143         kref_init(&rpipe->refcnt);
 144         spin_lock_init(&rpipe->seg_lock);
 145         INIT_LIST_HEAD(&rpipe->seg_list);
 146         INIT_LIST_HEAD(&rpipe->list_node);
 147 }
 148
 149 static unsigned rpipe_get_idx(struct wahc *wa, unsigned rpipe_idx)
 150 {
 151         unsigned long flags;
 152
 153         spin_lock_irqsave(&wa->rpipe_lock, flags);
 154         rpipe_idx = find_next_zero_bit(wa->rpipe_bm, wa->rpipes, rpipe_idx);
 155         if (rpipe_idx < wa->rpipes)
 156                 set_bit(rpipe_idx, wa->rpipe_bm);
 157         spin_unlock_irqrestore(&wa->rpipe_lock, flags);
 158
 159         return rpipe_idx;
 160 }
 161
 162 static void rpipe_put_idx(struct wahc *wa, unsigned rpipe_idx)
 163 {
 164         unsigned long flags;
 165
 166         spin_lock_irqsave(&wa->rpipe_lock, flags);
 167         clear_bit(rpipe_idx, wa->rpipe_bm);
 168         spin_unlock_irqrestore(&wa->rpipe_lock, flags);
 169 }
 170
 171 void rpipe_destroy(struct kref *_rpipe)
 172 {
 173         struct wa_rpipe *rpipe = container_of(_rpipe, struct wa_rpipe, refcnt);
 174         u8 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
 175
 176         if (rpipe->ep)
 177                 rpipe->ep->hcpriv = NULL;
 178         rpipe_put_idx(rpipe->wa, index);
 179         wa_put(rpipe->wa);
 180         kfree(rpipe);
 181 }
 182 EXPORT_SYMBOL_GPL(rpipe_destroy);
 183
 184 /*
 185  * Locate an idle rpipe, create an structure for it and return it
 186  *
 187  * @wa    is referenced and unlocked
 188  * @crs   enum rpipe_attr, required endpoint characteristics
 189  *
 190  * The rpipe can be used only sequentially (not in parallel).
 191  *
 192  * The rpipe is moved into the "ready" state.
 193  */
 194 static int rpipe_get_idle(struct wa_rpipe **prpipe, struct wahc *wa, u8 crs,
 195                           gfp_t gfp)
 196 {
 197         int result;
 198         unsigned rpipe_idx;
 199         struct wa_rpipe *rpipe;
 200         struct device *dev = &wa->usb_iface->dev;
 201
 202         rpipe = kzalloc(sizeof(*rpipe), gfp);
 203         if (rpipe == NULL)
 204                 return -ENOMEM;
 205         rpipe_init(rpipe);
 206
 207         /* Look for an idle pipe */
 208         for (rpipe_idx = 0; rpipe_idx < wa->rpipes; rpipe_idx++) {
 209                 rpipe_idx = rpipe_get_idx(wa, rpipe_idx);
 210                 if (rpipe_idx >= wa->rpipes)    /* no more pipes :( */
 211                         break;
 212                 result =  __rpipe_get_descr(wa, &rpipe->descr, rpipe_idx);
 213                 if (result < 0)
 214                         dev_err(dev, "Can't get descriptor for rpipe %u: %d\n",
 215                                 rpipe_idx, result);
 216                 else if ((rpipe->descr.bmCharacteristics & crs) != 0)
 217                         goto found;
 218                 rpipe_put_idx(wa, rpipe_idx);
 219         }
 220         *prpipe = NULL;
 221         kfree(rpipe);
 222         return -ENXIO;
 223
 224 found:
 225         set_bit(rpipe_idx, wa->rpipe_bm);
 226         rpipe->wa = wa_get(wa);
 227         *prpipe = rpipe;
 228         return 0;
 229 }
 230
 231 static int __rpipe_reset(struct wahc *wa, unsigned index)
 232 {
 233         int result;
 234         struct device *dev = &wa->usb_iface->dev;
 235
 236         result = usb_control_msg(
 237                 wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
 238                 USB_REQ_RPIPE_RESET,
 239                 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
 240                 0, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
 241         if (result < 0)
 242                 dev_err(dev, "rpipe %u: reset failed: %d\n",
 243                         index, result);
 244         return result;
 245 }
 246
 247 /*
 248  * Fake companion descriptor for ep0
 249  *
 250  * See WUSB1.0[7.4.4], most of this is zero for bulk/int/ctl
 251  */
 252 static struct usb_wireless_ep_comp_descriptor epc0 = {
 253         .bLength = sizeof(epc0),
 254         .bDescriptorType = USB_DT_WIRELESS_ENDPOINT_COMP,
 255         .bMaxBurst = 1,
 256         .bMaxSequence = 2,
 257 };
 258
 259 /*
 260  * Look for EP companion descriptor
 261  *
 262  * Get there, look for Inara in the endpoint's extra descriptors
 263  */
 264 static struct usb_wireless_ep_comp_descriptor *rpipe_epc_find(
 265                 struct device *dev, struct usb_host_endpoint *ep)
 266 {
 267         void *itr;
 268         size_t itr_size;
 269         struct usb_descriptor_header *hdr;
 270         struct usb_wireless_ep_comp_descriptor *epcd;
 271
 272         if (ep->desc.bEndpointAddress == 0) {
 273                 epcd = &epc0;
 274                 goto out;
 275         }
 276         itr = ep->extra;
 277         itr_size = ep->extralen;
 278         epcd = NULL;
 279         while (itr_size > 0) {
 280                 if (itr_size < sizeof(*hdr)) {
 281                         dev_err(dev, "HW Bug? ep 0x%02x: extra descriptors "
 282                                 "at offset %zu: only %zu bytes left\n",
 283                                 ep->desc.bEndpointAddress,
 284                                 itr - (void *) ep->extra, itr_size);
 285                         break;
 286                 }
 287                 hdr = itr;
 288                 if (hdr->bDescriptorType == USB_DT_WIRELESS_ENDPOINT_COMP) {
 289                         epcd = itr;
 290                         break;
 291                 }
 292                 if (hdr->bLength > itr_size) {
 293                         dev_err(dev, "HW Bug? ep 0x%02x: extra descriptor "
 294                                 "at offset %zu (type 0x%02x) "
 295                                 "length %d but only %zu bytes left\n",
 296                                 ep->desc.bEndpointAddress,
 297                                 itr - (void *) ep->extra, hdr->bDescriptorType,
 298                                 hdr->bLength, itr_size);
 299                         break;
 300                 }
 301                 itr += hdr->bLength;
 302                 itr_size -= hdr->bDescriptorType;
 303         }
 304 out:
 305         return epcd;
 306 }
 307
 308 /*
 309  * Aim an rpipe to its device & endpoint destination
 310  *
 311  * Make sure we change the address to unauthenticated if the device
 312  * is WUSB and it is not authenticated.
 313  */
 314 static int rpipe_aim(struct wa_rpipe *rpipe, struct wahc *wa,
 315                      struct usb_host_endpoint *ep, struct urb *urb, gfp_t gfp)
 316 {
 317         int result = -ENOMSG;   /* better code for lack of companion? */
 318         struct device *dev = &wa->usb_iface->dev;
 319         struct usb_device *usb_dev = urb->dev;
 320         struct usb_wireless_ep_comp_descriptor *epcd;
 321         u32 ack_window, epcd_max_sequence;
 322         u8 unauth;
 323
 324         epcd = rpipe_epc_find(dev, ep);
 325         if (epcd == NULL) {
 326                 dev_err(dev, "ep 0x%02x: can't find companion descriptor\n",
 327                         ep->desc.bEndpointAddress);
 328                 goto error;
 329         }
 330         unauth = usb_dev->wusb && !usb_dev->authenticated ? 0x80 : 0;
 331         __rpipe_reset(wa, le16_to_cpu(rpipe->descr.wRPipeIndex));
 332         atomic_set(&rpipe->segs_available, le16_to_cpu(rpipe->descr.wRequests));
 333         /* FIXME: block allocation system; request with queuing and timeout */
 334         /* FIXME: compute so seg_size > ep->maxpktsize */
 335         rpipe->descr.wBlocks = cpu_to_le16(16);         /* given */
 336         /* ep0 maxpktsize is 0x200 (WUSB1.0[4.8.1]) */
 337         if (usb_endpoint_xfer_isoc(&ep->desc))
 338                 rpipe->descr.wMaxPacketSize = epcd->wOverTheAirPacketSize;
 339         else
 340                 rpipe->descr.wMaxPacketSize = ep->desc.wMaxPacketSize;
 341
 342         rpipe->descr.hwa_bMaxBurst = max(min_t(unsigned int,
 343                                 epcd->bMaxBurst, 16U), 1U);
 344         rpipe->descr.hwa_bDeviceInfoIndex =
 345                         wusb_port_no_to_idx(urb->dev->portnum);
 346         /* FIXME: use maximum speed as supported or recommended by device */
 347         rpipe->descr.bSpeed = usb_pipeendpoint(urb->pipe) == 0 ?
 348                 UWB_PHY_RATE_53 : UWB_PHY_RATE_200;
 349
 350         dev_dbg(dev, "addr %u (0x%02x) rpipe #%u ep# %u speed %d\n",
 351                 urb->dev->devnum, urb->dev->devnum | unauth,
 352                 le16_to_cpu(rpipe->descr.wRPipeIndex),
 353                 usb_pipeendpoint(urb->pipe), rpipe->descr.bSpeed);
 354
 355         rpipe->descr.hwa_reserved = 0;
 356
 357         rpipe->descr.bEndpointAddress = ep->desc.bEndpointAddress;
 358         /* FIXME: bDataSequence */
 359         rpipe->descr.bDataSequence = 0;
 360
 361         /* start with base window of hwa_bMaxBurst bits starting at 0. */
 362         ack_window = 0xFFFFFFFF >> (32 - rpipe->descr.hwa_bMaxBurst);
 363         rpipe->descr.dwCurrentWindow = cpu_to_le32(ack_window);
 364         epcd_max_sequence = max(min_t(unsigned int,
 365                         epcd->bMaxSequence, 32U), 2U);
 366         rpipe->descr.bMaxDataSequence = epcd_max_sequence - 1;
 367         rpipe->descr.bInterval = ep->desc.bInterval;
 368         if (usb_endpoint_xfer_isoc(&ep->desc))
 369                 rpipe->descr.bOverTheAirInterval = epcd->bOverTheAirInterval;
 370         else
 371                 rpipe->descr.bOverTheAirInterval = 0;   /* 0 if not isoc */
 372         /* FIXME: xmit power & preamble blah blah */
 373         rpipe->descr.bmAttribute = (ep->desc.bmAttributes &
 374                                         USB_ENDPOINT_XFERTYPE_MASK);
 375         /* rpipe->descr.bmCharacteristics RO */
 376         rpipe->descr.bmRetryOptions = (wa->wusb->retry_count & 0xF);
 377         /* FIXME: use for assessing link quality? */
 378         rpipe->descr.wNumTransactionErrors = 0;
 379         result = __rpipe_set_descr(wa, &rpipe->descr,
 380                                    le16_to_cpu(rpipe->descr.wRPipeIndex));
 381         if (result < 0) {
 382                 dev_err(dev, "Cannot aim rpipe: %d\n", result);
 383                 goto error;
 384         }
 385         result = 0;
 386 error:
 387         return result;
 388 }
 389
 390 /*
 391  * Check an aimed rpipe to make sure it points to where we want
 392  *
 393  * We use bit 19 of the Linux USB pipe bitmap for unauth vs auth
 394  * space; when it is like that, we or 0x80 to make an unauth address.
 395  */
 396 static int rpipe_check_aim(const struct wa_rpipe *rpipe, const struct wahc *wa,
 397                            const struct usb_host_endpoint *ep,
 398                            const struct urb *urb, gfp_t gfp)
 399 {
 400         int result = 0;
 401         struct device *dev = &wa->usb_iface->dev;
 402         u8 portnum = wusb_port_no_to_idx(urb->dev->portnum);
 403
 404 #define AIM_CHECK(rdf, val, text)                                       \
 405         do {                                                            \
 406                 if (rpipe->descr.rdf != (val)) {                        \
 407                         dev_err(dev,                                    \
 408                                 "rpipe aim discrepancy: " #rdf " " text "\n", \
 409                                 rpipe->descr.rdf, (val));               \
 410                         result = -EINVAL;                               \
 411                         WARN_ON(1);                                     \
 412                 }                                                       \
 413         } while (0)
 414         AIM_CHECK(hwa_bDeviceInfoIndex, portnum, "(%u vs %u)");
 415         AIM_CHECK(bSpeed, usb_pipeendpoint(urb->pipe) == 0 ?
 416                         UWB_PHY_RATE_53 : UWB_PHY_RATE_200,
 417                   "(%u vs %u)");
 418         AIM_CHECK(bEndpointAddress, ep->desc.bEndpointAddress, "(%u vs %u)");
 419         AIM_CHECK(bInterval, ep->desc.bInterval, "(%u vs %u)");
 420         AIM_CHECK(bmAttribute, ep->desc.bmAttributes & 0x03, "(%u vs %u)");
 421 #undef AIM_CHECK
 422         return result;
 423 }
 424
 425 #ifndef CONFIG_BUG
 426 #define CONFIG_BUG 0
 427 #endif
 428
 429 /*
 430  * Make sure there is an rpipe allocated for an endpoint
 431  *
 432  * If already allocated, we just refcount it; if not, we get an
 433  * idle one, aim it to the right location and take it.
 434  *
 435  * Attaches to ep->hcpriv and rpipe->ep to ep.
 436  */
 437 int rpipe_get_by_ep(struct wahc *wa, struct usb_host_endpoint *ep,
 438                     struct urb *urb, gfp_t gfp)
 439 {
 440         int result = 0;
 441         struct device *dev = &wa->usb_iface->dev;
 442         struct wa_rpipe *rpipe;
 443         u8 eptype;
 444
 445         mutex_lock(&wa->rpipe_mutex);
 446         rpipe = ep->hcpriv;
 447         if (rpipe != NULL) {
 448                 if (CONFIG_BUG == 1) {
 449                         result = rpipe_check_aim(rpipe, wa, ep, urb, gfp);
 450                         if (result < 0)
 451                                 goto error;
 452                 }
 453                 __rpipe_get(rpipe);
 454                 dev_dbg(dev, "ep 0x%02x: reusing rpipe %u\n",
 455                         ep->desc.bEndpointAddress,
 456                         le16_to_cpu(rpipe->descr.wRPipeIndex));
 457         } else {
 458                 /* hmm, assign idle rpipe, aim it */
 459                 result = -ENOBUFS;
 460                 eptype = ep->desc.bmAttributes & 0x03;
 461                 result = rpipe_get_idle(&rpipe, wa, 1 << eptype, gfp);
 462                 if (result < 0)
 463                         goto error;
 464                 result = rpipe_aim(rpipe, wa, ep, urb, gfp);
 465                 if (result < 0) {
 466                         rpipe_put(rpipe);
 467                         goto error;
 468                 }
 469                 ep->hcpriv = rpipe;
 470                 rpipe->ep = ep;
 471                 __rpipe_get(rpipe);     /* for caching into ep->hcpriv */
 472                 dev_dbg(dev, "ep 0x%02x: using rpipe %u\n",
 473                         ep->desc.bEndpointAddress,
 474                         le16_to_cpu(rpipe->descr.wRPipeIndex));
 475         }
 476 error:
 477         mutex_unlock(&wa->rpipe_mutex);
 478         return result;
 479 }
 480
 481 /*
 482  * Allocate the bitmap for each rpipe.
 483  */
 484 int wa_rpipes_create(struct wahc *wa)
 485 {
 486         wa->rpipes = le16_to_cpu(wa->wa_descr->wNumRPipes);
 487         wa->rpipe_bm = kzalloc(BITS_TO_LONGS(wa->rpipes)*sizeof(unsigned long),
 488                                GFP_KERNEL);
 489         if (wa->rpipe_bm == NULL)
 490                 return -ENOMEM;
 491         return 0;
 492 }
 493
 494 void wa_rpipes_destroy(struct wahc *wa)
 495 {
 496         struct device *dev = &wa->usb_iface->dev;
 497
 498         if (!bitmap_empty(wa->rpipe_bm, wa->rpipes)) {
 499                 char buf[256];
 500                 WARN_ON(1);
 501                 bitmap_scnprintf(buf, sizeof(buf), wa->rpipe_bm, wa->rpipes);
 502                 dev_err(dev, "BUG: pipes not released on exit: %s\n", buf);
 503         }
 504         kfree(wa->rpipe_bm);
 505 }
 506
 507 /*
 508  * Release resources allocated for an endpoint
 509  *
 510  * If there is an associated rpipe to this endpoint, Abort any pending
 511  * transfers and put it. If the rpipe ends up being destroyed,
 512  * __rpipe_destroy() will cleanup ep->hcpriv.
 513  *
 514  * This is called before calling hcd->stop(), so you don't need to do
 515  * anything else in there.
 516  */
 517 void rpipe_ep_disable(struct wahc *wa, struct usb_host_endpoint *ep)
 518 {
 519         struct wa_rpipe *rpipe;
 520
 521         mutex_lock(&wa->rpipe_mutex);
 522         rpipe = ep->hcpriv;
 523         if (rpipe != NULL) {
 524                 u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
 525
 526                 usb_control_msg(
 527                         wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
 528                         USB_REQ_RPIPE_ABORT,
 529                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
 530                         0, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
 531                 rpipe_put(rpipe);
 532         }
 533         mutex_unlock(&wa->rpipe_mutex);
 534 }
 535 EXPORT_SYMBOL_GPL(rpipe_ep_disable);
 536
 537 /* Clear the stalled status of an RPIPE. */
 538 void rpipe_clear_feature_stalled(struct wahc *wa, struct usb_host_endpoint *ep)
 539 {
 540         struct wa_rpipe *rpipe;
 541
 542         mutex_lock(&wa->rpipe_mutex);
 543         rpipe = ep->hcpriv;
 544         if (rpipe != NULL) {
 545                 u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
 546
 547                 usb_control_msg(
 548                         wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
 549                         USB_REQ_CLEAR_FEATURE,
 550                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
 551                         RPIPE_STALL, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
 552         }
 553         mutex_unlock(&wa->rpipe_mutex);
 554 }
 555 EXPORT_SYMBOL_GPL(rpipe_clear_feature_stalled);
 556