| 1 | /***************************************************************************** |
| 2 | ** FILE NAME : ifxhcd_queue.c |
| 3 | ** PROJECT : IFX USB sub-system V3 |
| 4 | ** MODULES : IFX USB sub-system Host and Device driver |
| 5 | ** SRC VERSION : 3.2 |
| 6 | ** DATE : 1/Jan/2011 |
| 7 | ** AUTHOR : Chen, Howard |
| 8 | ** DESCRIPTION : This file contains the functions to manage Queue Heads and Queue |
| 9 | ** Transfer Descriptors. |
| 10 | ** FUNCTIONS : |
| 11 | ** COMPILER : gcc |
| 12 | ** REFERENCE : Synopsys DWC-OTG Driver 2.7 |
| 13 | ** COPYRIGHT : Copyright (c) 2010 |
| 14 | ** LANTIQ DEUTSCHLAND GMBH, |
| 15 | ** Am Campeon 3, 85579 Neubiberg, Germany |
| 16 | ** |
| 17 | ** This program is free software; you can redistribute it and/or modify |
| 18 | ** it under the terms of the GNU General Public License as published by |
| 19 | ** the Free Software Foundation; either version 2 of the License, or |
| 20 | ** (at your option) any later version. |
| 21 | ** |
| 22 | ** Version Control Section ** |
| 23 | ** $Author$ |
| 24 | ** $Date$ |
| 25 | ** $Revisions$ |
| 26 | ** $Log$ Revision history |
| 27 | *****************************************************************************/ |
| 28 | |
| 29 | /* |
| 30 | * This file contains code fragments from Synopsys HS OTG Linux Software Driver. |
| 31 | * For this code the following notice is applicable: |
| 32 | * |
| 33 | * ========================================================================== |
| 34 | * |
| 35 | * Synopsys HS OTG Linux Software Driver and documentation (hereinafter, |
| 36 | * "Software") is an Unsupported proprietary work of Synopsys, Inc. unless |
| 37 | * otherwise expressly agreed to in writing between Synopsys and you. |
| 38 | * |
| 39 | * The Software IS NOT an item of Licensed Software or Licensed Product under |
| 40 | * any End User Software License Agreement or Agreement for Licensed Product |
| 41 | * with Synopsys or any supplement thereto. You are permitted to use and |
| 42 | * redistribute this Software in source and binary forms, with or without |
| 43 | * modification, provided that redistributions of source code must retain this |
| 44 | * notice. You may not view, use, disclose, copy or distribute this file or |
| 45 | * any information contained herein except pursuant to this license grant from |
| 46 | * Synopsys. If you do not agree with this notice, including the disclaimer |
| 47 | * below, then you are not authorized to use the Software. |
| 48 | * |
| 49 | * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" BASIS |
| 50 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 51 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 52 | * ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS BE LIABLE FOR ANY DIRECT, |
| 53 | * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| 54 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| 55 | * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| 56 | * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| 57 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| 58 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH |
| 59 | * DAMAGE. |
| 60 | * ========================================================================== */ |
| 61 | |
| 62 | /*! |
| 63 | \file ifxhcd_queue.c |
| 64 | \ingroup IFXUSB_DRIVER_V3 |
| 65 | \brief This file contains the functions to manage Queue Heads and Queue |
| 66 | Transfer Descriptors. |
| 67 | */ |
| 68 | #include <linux/version.h> |
| 69 | #include "ifxusb_version.h" |
| 70 | |
| 71 | #include <linux/kernel.h> |
| 72 | #include <linux/module.h> |
| 73 | #include <linux/moduleparam.h> |
| 74 | #include <linux/init.h> |
| 75 | #include <linux/device.h> |
| 76 | #include <linux/errno.h> |
| 77 | #include <linux/list.h> |
| 78 | #include <linux/interrupt.h> |
| 79 | #include <linux/string.h> |
| 80 | |
| 81 | #include "ifxusb_plat.h" |
| 82 | #include "ifxusb_regs.h" |
| 83 | #include "ifxusb_cif.h" |
| 84 | #include "ifxhcd.h" |
| 85 | |
| 86 | #ifdef __EPQD_DESTROY_TIMEOUT__ |
| 87 | #define epqh_self_destroy_timeout 300 |
| 88 | static void eqph_destroy_func(unsigned long _ptr) |
| 89 | { |
| 90 | ifxhcd_epqh_t *epqh=(ifxhcd_epqh_t *)_ptr; |
| 91 | if(epqh) |
| 92 | { |
| 93 | if(epqh->sysep) |
| 94 | { |
| 95 | epqh->sysep->hcpriv=NULL; |
| 96 | } |
| 97 | ifxhcd_epqh_free (epqh); |
| 98 | } |
| 99 | } |
| 100 | #endif |
| 101 | |
| 102 | /*! |
| 103 | \brief This function allocates and initializes a EPQH. |
| 104 | |
| 105 | \param _ifxhcd The HCD state structure for the USB Host controller. |
| 106 | \param[in] _urb Holds the information about the device/endpoint that we need |
| 107 | to initialize the EPQH. |
| 108 | |
| 109 | \return Returns pointer to the newly allocated EPQH, or NULL on error. |
| 110 | */ |
| 111 | static ifxhcd_epqh_t *ifxhcd_epqh_create (ifxhcd_hcd_t *_ifxhcd, struct urb *_urb) |
| 112 | { |
| 113 | ifxhcd_epqh_t *epqh; |
| 114 | |
| 115 | hprt0_data_t hprt0; |
| 116 | struct usb_host_endpoint *sysep = ifxhcd_urb_to_endpoint(_urb); |
| 117 | |
| 118 | /* Allocate memory */ |
| 119 | // epqh=(ifxhcd_epqh_t *) kmalloc (sizeof(ifxhcd_epqh_t), GFP_KERNEL); |
| 120 | epqh=(ifxhcd_epqh_t *) kmalloc (sizeof(ifxhcd_epqh_t), GFP_ATOMIC); |
| 121 | |
| 122 | if(epqh == NULL) |
| 123 | return NULL; |
| 124 | |
| 125 | memset (epqh, 0, sizeof (ifxhcd_epqh_t)); |
| 126 | |
| 127 | epqh->sysep=sysep; |
| 128 | |
| 129 | epqh->devno=_urb->dev->devnum; |
| 130 | |
| 131 | epqh->ifxhcd=_ifxhcd; |
| 132 | epqh->phase=EPQH_IDLE; |
| 133 | |
| 134 | /* Initialize EPQH */ |
| 135 | switch (usb_pipetype(_urb->pipe)) |
| 136 | { |
| 137 | case PIPE_CONTROL : epqh->ep_type = IFXUSB_EP_TYPE_CTRL; break; |
| 138 | case PIPE_BULK : epqh->ep_type = IFXUSB_EP_TYPE_BULK; break; |
| 139 | case PIPE_ISOCHRONOUS: epqh->ep_type = IFXUSB_EP_TYPE_ISOC; break; |
| 140 | case PIPE_INTERRUPT : epqh->ep_type = IFXUSB_EP_TYPE_INTR; break; |
| 141 | } |
| 142 | |
| 143 | usb_settoggle(_urb->dev, usb_pipeendpoint (_urb->pipe), !usb_pipein(_urb->pipe), IFXUSB_HC_PID_DATA0); |
| 144 | epqh->mps = usb_maxpacket(_urb->dev, _urb->pipe, !(usb_pipein(_urb->pipe))); |
| 145 | |
| 146 | INIT_LIST_HEAD(&epqh->urbd_list); |
| 147 | #ifdef __STRICT_ORDER__ |
| 148 | INIT_LIST_HEAD(&epqh->release_list); |
| 149 | #endif |
| 150 | INIT_LIST_HEAD(&epqh->ql); |
| 151 | INIT_LIST_HEAD(&epqh->ql_all); |
| 152 | INIT_URBD_LIST(epqh); |
| 153 | |
| 154 | epqh->hc = NULL; |
| 155 | |
| 156 | /* FS/LS Enpoint on HS Hub |
| 157 | * NOT virtual root hub */ |
| 158 | epqh->need_split = 0; |
| 159 | hprt0.d32 = ifxusb_read_hprt0 (&_ifxhcd->core_if); |
| 160 | if (hprt0.b.prtspd == IFXUSB_HPRT0_PRTSPD_HIGH_SPEED && |
| 161 | ((_urb->dev->speed == USB_SPEED_LOW) || |
| 162 | (_urb->dev->speed == USB_SPEED_FULL)) && |
| 163 | (_urb->dev->tt) && (_urb->dev->tt->hub) && (_urb->dev->tt->hub->devnum != 1)) |
| 164 | { |
| 165 | IFX_DEBUGPL(DBG_HCD, "QH init: EP %d: TT found at hub addr %d, for port %d\n", |
| 166 | usb_pipeendpoint(_urb->pipe), _urb->dev->tt->hub->devnum, |
| 167 | _urb->dev->ttport); |
| 168 | epqh->need_split = 1; |
| 169 | } |
| 170 | |
| 171 | if (epqh->ep_type == IFXUSB_EP_TYPE_INTR || |
| 172 | epqh->ep_type == IFXUSB_EP_TYPE_ISOC) |
| 173 | { |
| 174 | /* Compute scheduling parameters once and save them. */ |
| 175 | epqh->interval = _urb->interval; |
| 176 | if(epqh->need_split) |
| 177 | epqh->interval *= 8; |
| 178 | } |
| 179 | |
| 180 | #ifdef __EN_ISOC__ |
| 181 | if (epqh->ep_type == IFXUSB_EP_TYPE_ISOC) |
| 182 | _ifxhcd->isoc_ep_count++; |
| 183 | #endif |
| 184 | |
| 185 | epqh->period_counter=0; |
| 186 | |
| 187 | #ifdef __EPQD_DESTROY_TIMEOUT__ |
| 188 | /* Start a timer for this transfer. */ |
| 189 | init_timer(&epqh->destroy_timer); |
| 190 | epqh->destroy_timer.function = eqph_destroy_func; |
| 191 | epqh->destroy_timer.data = (unsigned long)(epqh); |
| 192 | #endif |
| 193 | |
| 194 | #ifdef __DEBUG__ |
| 195 | IFX_DEBUGPL(DBG_HCD , "IFXUSB HCD EPQH Initialized\n"); |
| 196 | IFX_DEBUGPL(DBG_HCDV, "IFXUSB HCD EPQH - epqh = %p\n", epqh); |
| 197 | IFX_DEBUGPL(DBG_HCDV, "IFXUSB HCD EPQH - Device Address = %d EP %d, %s\n", |
| 198 | _urb->dev->devnum, |
| 199 | usb_pipeendpoint(_urb->pipe), |
| 200 | usb_pipein(_urb->pipe) == USB_DIR_IN ? "IN" : "OUT"); |
| 201 | IFX_DEBUGPL(DBG_HCDV, "IFXUSB HCD EPQH - Speed = %s\n", |
| 202 | ({ char *speed; switch (_urb->dev->speed) { |
| 203 | case USB_SPEED_LOW: speed = "low" ; break; |
| 204 | case USB_SPEED_FULL: speed = "full"; break; |
| 205 | case USB_SPEED_HIGH: speed = "high"; break; |
| 206 | default: speed = "?"; break; |
| 207 | }; speed;})); |
| 208 | IFX_DEBUGPL(DBG_HCDV, "IFXUSB HCD EPQH - Type = %s\n", |
| 209 | ({ |
| 210 | char *type; switch (epqh->ep_type) |
| 211 | { |
| 212 | case IFXUSB_EP_TYPE_ISOC: type = "isochronous"; break; |
| 213 | case IFXUSB_EP_TYPE_INTR: type = "interrupt" ; break; |
| 214 | case IFXUSB_EP_TYPE_CTRL: type = "control" ; break; |
| 215 | case IFXUSB_EP_TYPE_BULK: type = "bulk" ; break; |
| 216 | default: type = "?"; break; |
| 217 | }; |
| 218 | type; |
| 219 | })); |
| 220 | if (epqh->ep_type == IFXUSB_EP_TYPE_INTR) |
| 221 | IFX_DEBUGPL(DBG_HCDV, "IFXUSB HCD EPQH - interval = %d\n", epqh->interval); |
| 222 | #endif |
| 223 | |
| 224 | LOCK_EPQH_LIST_ALL(_ifxhcd); |
| 225 | list_add_tail(&epqh->ql_all, &_ifxhcd->epqh_list_all); |
| 226 | UNLOCK_EPQH_LIST_ALL(_ifxhcd); |
| 227 | |
| 228 | LOCK_EPQH_LIST(_ifxhcd); |
| 229 | switch (epqh->ep_type) |
| 230 | { |
| 231 | case IFXUSB_EP_TYPE_CTRL: |
| 232 | case IFXUSB_EP_TYPE_BULK: |
| 233 | |
| 234 | list_add_tail(&epqh->ql, &_ifxhcd->epqh_list_np); |
| 235 | break; |
| 236 | case IFXUSB_EP_TYPE_INTR: |
| 237 | list_add_tail(&epqh->ql, &_ifxhcd->epqh_list_intr); |
| 238 | break; |
| 239 | #ifdef __EN_ISOC__ |
| 240 | case IFXUSB_EP_TYPE_ISOC: |
| 241 | list_add_tail(&epqh->ql, &_ifxhcd->epqh_list_isoc); |
| 242 | |
| 243 | break; |
| 244 | #endif |
| 245 | } |
| 246 | UNLOCK_EPQH_LIST(_ifxhcd); |
| 247 | return epqh; |
| 248 | } |
| 249 | |
| 250 | |
| 251 | |
| 252 | |
| 253 | |
| 254 | |
| 255 | /*! |
| 256 | \brief Free the EPQH. EPQH should already be removed from a list. |
| 257 | URBD list should already be empty if called from URB Dequeue. |
| 258 | |
| 259 | \param[in] _epqh The EPQH to free. |
| 260 | */ |
| 261 | void ifxhcd_epqh_free (ifxhcd_epqh_t *_epqh) |
| 262 | { |
| 263 | unsigned long flags; |
| 264 | if(!_epqh) |
| 265 | return; |
| 266 | |
| 267 | if(_epqh->sysep) _epqh->sysep->hcpriv=NULL; |
| 268 | _epqh->sysep=NULL; |
| 269 | |
| 270 | local_irq_save (flags); |
| 271 | if (!list_empty(&_epqh->urbd_list)) |
| 272 | IFX_WARN("%s() invalid epqh state\n",__func__); |
| 273 | else |
| 274 | { |
| 275 | LOCK_EPQH_LIST_ALL(_epqh->ifxhcd); |
| 276 | if (!list_empty(&_epqh->ql_all)) |
| 277 | list_del_init (&_epqh->ql_all); |
| 278 | UNLOCK_EPQH_LIST_ALL(_epqh->ifxhcd); |
| 279 | |
| 280 | LOCK_EPQH_LIST(_epqh->ifxhcd); |
| 281 | if (!list_empty(&_epqh->ql)) |
| 282 | list_del_init (&_epqh->ql); |
| 283 | UNLOCK_EPQH_LIST(_epqh->ifxhcd); |
| 284 | |
| 285 | #ifdef __EPQD_DESTROY_TIMEOUT__ |
| 286 | del_timer(&_epqh->destroy_timer); |
| 287 | #endif |
| 288 | kfree (_epqh); |
| 289 | } |
| 290 | local_irq_restore (flags); |
| 291 | } |
| 292 | |
| 293 | |
| 294 | void ifxhcd_epqh_idle(ifxhcd_epqh_t *_epqh) |
| 295 | { |
| 296 | unsigned long flags; |
| 297 | local_irq_save(flags); |
| 298 | LOCK_URBD_LIST(_epqh); |
| 299 | if (list_empty(&_epqh->urbd_list)) |
| 300 | { |
| 301 | if(_epqh->ep_type == IFXUSB_EP_TYPE_ISOC || _epqh->ep_type == IFXUSB_EP_TYPE_INTR) |
| 302 | _epqh->phase=EPQH_STDBY; |
| 303 | else |
| 304 | { |
| 305 | _epqh->phase=EPQH_IDLE; |
| 306 | #ifdef __EPQD_DESTROY_TIMEOUT__ |
| 307 | del_timer(&_epqh->destroy_timer); |
| 308 | _epqh->destroy_timer.expires = jiffies + (HZ*epqh_self_destroy_timeout); |
| 309 | add_timer(&_epqh->destroy_timer ); |
| 310 | #endif |
| 311 | } |
| 312 | } |
| 313 | else |
| 314 | { |
| 315 | _epqh->phase=EPQH_READY; |
| 316 | #ifdef __EPQD_DESTROY_TIMEOUT__ |
| 317 | del_timer(&_epqh->destroy_timer); |
| 318 | #endif |
| 319 | } |
| 320 | UNLOCK_URBD_LIST(_epqh); |
| 321 | local_irq_restore(flags); |
| 322 | } |
| 323 | |
| 324 | |
| 325 | void ifxhcd_epqh_idle_periodic(ifxhcd_epqh_t *_epqh) |
| 326 | { |
| 327 | unsigned long flags; |
| 328 | if(_epqh->ep_type != IFXUSB_EP_TYPE_ISOC && _epqh->ep_type != IFXUSB_EP_TYPE_INTR && _epqh->phase!=EPQH_STDBY) |
| 329 | return; |
| 330 | |
| 331 | local_irq_save(flags); |
| 332 | LOCK_URBD_LIST(_epqh); |
| 333 | if (!list_empty(&_epqh->urbd_list)) |
| 334 | IFX_WARN("%s() invalid epqh state(not empty)\n",__func__); |
| 335 | |
| 336 | _epqh->phase=EPQH_IDLE; |
| 337 | |
| 338 | #ifdef __EPQD_DESTROY_TIMEOUT__ |
| 339 | del_timer(&_epqh->destroy_timer); |
| 340 | _epqh->destroy_timer.expires = jiffies + (HZ*epqh_self_destroy_timeout); |
| 341 | add_timer(&_epqh->destroy_timer ); |
| 342 | #endif |
| 343 | |
| 344 | #ifdef __EN_ISOC__ |
| 345 | if (_epqh->ep_type == IFXUSB_EP_TYPE_ISOC) |
| 346 | _epqh->ifxhcd->isoc_ep_count--; |
| 347 | #endif |
| 348 | UNLOCK_URBD_LIST(_epqh); |
| 349 | local_irq_restore(flags); |
| 350 | } |
| 351 | |
| 352 | |
| 353 | ifxhcd_epqh_t *ifxhcd_urbd_create (ifxhcd_hcd_t *_ifxhcd,struct urb *_urb) |
| 354 | { |
| 355 | ifxhcd_urbd_t *urbd; |
| 356 | struct usb_host_endpoint *sysep; |
| 357 | ifxhcd_epqh_t *epqh=NULL; |
| 358 | unsigned long flags; |
| 359 | |
| 360 | local_irq_save(flags); |
| 361 | |
| 362 | sysep = ifxhcd_urb_to_endpoint(_urb); |
| 363 | |
| 364 | LOCK_EPQH_LIST_ALL(_ifxhcd); |
| 365 | epqh = sysep_to_epqh(_ifxhcd, sysep); |
| 366 | |
| 367 | if (!epqh) |
| 368 | { |
| 369 | sysep->hcpriv = NULL; |
| 370 | epqh = ifxhcd_epqh_create (_ifxhcd, _urb); |
| 371 | } |
| 372 | UNLOCK_EPQH_LIST_ALL(_ifxhcd); |
| 373 | |
| 374 | if (!epqh) |
| 375 | { |
| 376 | IFX_ERROR("EPQH Error alloc\n"); |
| 377 | local_irq_restore (flags); |
| 378 | return (ifxhcd_epqh_t *)NULL; |
| 379 | } |
| 380 | if(epqh->phase==EPQH_DISABLING) |
| 381 | { |
| 382 | IFX_ERROR("EPQH Error alloc while disabling\n"); |
| 383 | local_irq_restore (flags); |
| 384 | return (ifxhcd_epqh_t *)NULL; |
| 385 | } |
| 386 | sysep->hcpriv = epqh; |
| 387 | |
| 388 | if(_urb->hcpriv) |
| 389 | { |
| 390 | IFX_WARN("%s() Previous urb->hcpriv exist %p\n",__func__,_urb->hcpriv); |
| 391 | #if 1 |
| 392 | local_irq_restore (flags); |
| 393 | return (ifxhcd_epqh_t *)NULL; |
| 394 | #else |
| 395 | urbd = _urb->hcpriv; |
| 396 | if(urbd->epqh!=epqh) |
| 397 | IFX_WARN("%s() Previous urb->hcpriv exist %p and epqh not the same %p %p\n",__func__,_urb->hcpriv,urbd->epqh,epqh); |
| 398 | #endif |
| 399 | } |
| 400 | else |
| 401 | { |
| 402 | urbd = (ifxhcd_urbd_t *) kmalloc (sizeof(ifxhcd_urbd_t), GFP_ATOMIC); |
| 403 | if (!urbd) |
| 404 | { |
| 405 | local_irq_restore (flags); |
| 406 | return (ifxhcd_epqh_t *)NULL; |
| 407 | } |
| 408 | memset (urbd, 0, sizeof (ifxhcd_urbd_t)); |
| 409 | INIT_LIST_HEAD(&urbd->ql); |
| 410 | } |
| 411 | |
| 412 | _urb->hcpriv = urbd; |
| 413 | urbd->urb = _urb; |
| 414 | urbd->epqh = epqh; |
| 415 | urbd->status= -EINPROGRESS; |
| 416 | |
| 417 | urbd->is_in=usb_pipein(_urb->pipe) ? 1 : 0; |
| 418 | #define URB_NO_SETUP_DMA_MAP 0 |
| 419 | #ifdef __EN_ISOC__ |
| 420 | if(epqh->ep_type == IFXUSB_EP_TYPE_ISOC) |
| 421 | { |
| 422 | if(_urb->transfer_flags && URB_NO_TRANSFER_DMA_MAP) |
| 423 | urbd->xfer_buff = (uint8_t *) (KSEG1ADDR((uint32_t *)_urb->transfer_dma)); |
| 424 | else |
| 425 | urbd->xfer_buff = (uint8_t *) _urb->transfer_buffer; |
| 426 | } |
| 427 | else |
| 428 | #endif |
| 429 | { |
| 430 | urbd->xfer_len=_urb->transfer_buffer_length; |
| 431 | if(urbd->xfer_len>0) |
| 432 | { |
| 433 | if(_urb->transfer_flags && URB_NO_TRANSFER_DMA_MAP) |
| 434 | urbd->xfer_buff = (uint8_t *) (KSEG1ADDR((uint32_t *)_urb->transfer_dma)); |
| 435 | else |
| 436 | urbd->xfer_buff = (uint8_t *) _urb->transfer_buffer; |
| 437 | } |
| 438 | } |
| 439 | |
| 440 | #if 1 // cache write-back, so DMA engine can get correct content. Precaution |
| 441 | if(urbd->xfer_len) |
| 442 | dma_cache_wback_inv((unsigned long)urbd->xfer_buff, urbd->xfer_len); |
| 443 | #endif |
| 444 | |
| 445 | if(epqh->ep_type == IFXUSB_EP_TYPE_CTRL) |
| 446 | { |
| 447 | if(_urb->transfer_flags && URB_NO_SETUP_DMA_MAP) |
| 448 | urbd->setup_buff = (uint8_t *) (KSEG1ADDR((uint32_t *)_urb->setup_dma)); |
| 449 | else |
| 450 | urbd->setup_buff = (uint8_t *) _urb->setup_packet; |
| 451 | #if 1 // cache write-back, so DMA engine can get correct content. Precaution |
| 452 | dma_cache_wback_inv((unsigned long)urbd->setup_buff, 16); |
| 453 | #endif |
| 454 | } |
| 455 | |
| 456 | LOCK_URBD_LIST(epqh); |
| 457 | if (!list_empty(&urbd->ql)) |
| 458 | list_del_init(&urbd->ql); |
| 459 | list_add_tail(&urbd->ql, &epqh->urbd_list); |
| 460 | epqh->urbd_count++; |
| 461 | UNLOCK_URBD_LIST(epqh); |
| 462 | |
| 463 | local_irq_restore (flags); |
| 464 | return epqh; |
| 465 | } |
| 466 | |
| 467 | |
| 468 | |
| 469 | ifxhcd_epqh_t * sysep_to_epqh(ifxhcd_hcd_t *_ifxhcd, struct usb_host_endpoint *_sysep) |
| 470 | { |
| 471 | ifxhcd_epqh_t *epqh; |
| 472 | |
| 473 | LOCK_EPQH_LIST_ALL(_ifxhcd); |
| 474 | list_for_each_entry( epqh, &_ifxhcd->epqh_list_all, ql_all) |
| 475 | { |
| 476 | if(epqh->sysep==_sysep) |
| 477 | { |
| 478 | UNLOCK_EPQH_LIST_ALL(_ifxhcd); |
| 479 | return epqh; |
| 480 | } |
| 481 | } |
| 482 | UNLOCK_EPQH_LIST_ALL(_ifxhcd); |
| 483 | return NULL; |
| 484 | } |
| 485 | |
| 486 | |
