LCOV - code coverage report
Current view: top level - drivers/usb/host/dwc_otg - dwc_otg_pcd.c (source / functions) Hit Total Coverage
Test: Real Lines: 86 617 13.9 %
Date: 2020-10-17 15:46:16 Functions: 0 33 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* ==========================================================================
       2                 :            :  * $File: //dwh/usb_iip/dev/software/otg/linux/drivers/dwc_otg_pcd.c $
       3                 :            :  * $Revision: #101 $
       4                 :            :  * $Date: 2012/08/10 $
       5                 :            :  * $Change: 2047372 $
       6                 :            :  *
       7                 :            :  * Synopsys HS OTG Linux Software Driver and documentation (hereinafter,
       8                 :            :  * "Software") is an Unsupported proprietary work of Synopsys, Inc. unless
       9                 :            :  * otherwise expressly agreed to in writing between Synopsys and you.
      10                 :            :  *
      11                 :            :  * The Software IS NOT an item of Licensed Software or Licensed Product under
      12                 :            :  * any End User Software License Agreement or Agreement for Licensed Product
      13                 :            :  * with Synopsys or any supplement thereto. You are permitted to use and
      14                 :            :  * redistribute this Software in source and binary forms, with or without
      15                 :            :  * modification, provided that redistributions of source code must retain this
      16                 :            :  * notice. You may not view, use, disclose, copy or distribute this file or
      17                 :            :  * any information contained herein except pursuant to this license grant from
      18                 :            :  * Synopsys. If you do not agree with this notice, including the disclaimer
      19                 :            :  * below, then you are not authorized to use the Software.
      20                 :            :  *
      21                 :            :  * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" BASIS
      22                 :            :  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      23                 :            :  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      24                 :            :  * ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS BE LIABLE FOR ANY DIRECT,
      25                 :            :  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
      26                 :            :  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
      27                 :            :  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
      28                 :            :  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      29                 :            :  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      30                 :            :  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
      31                 :            :  * DAMAGE.
      32                 :            :  * ========================================================================== */
      33                 :            : #ifndef DWC_HOST_ONLY
      34                 :            : 
      35                 :            : /** @file
      36                 :            :  * This file implements PCD Core. All code in this file is portable and doesn't
      37                 :            :  * use any OS specific functions.
      38                 :            :  * PCD Core provides Interface, defined in <code><dwc_otg_pcd_if.h></code>
      39                 :            :  * header file, which can be used to implement OS specific PCD interface.
      40                 :            :  *
      41                 :            :  * An important function of the PCD is managing interrupts generated
      42                 :            :  * by the DWC_otg controller. The implementation of the DWC_otg device
      43                 :            :  * mode interrupt service routines is in dwc_otg_pcd_intr.c.
      44                 :            :  *
      45                 :            :  * @todo Add Device Mode test modes (Test J mode, Test K mode, etc).
      46                 :            :  * @todo Does it work when the request size is greater than DEPTSIZ
      47                 :            :  * transfer size
      48                 :            :  *
      49                 :            :  */
      50                 :            : 
      51                 :            : #include "dwc_otg_pcd.h"
      52                 :            : 
      53                 :            : #ifdef DWC_UTE_CFI
      54                 :            : #include "dwc_otg_cfi.h"
      55                 :            : 
      56                 :            : extern int init_cfi(cfiobject_t * cfiobj);
      57                 :            : #endif
      58                 :            : 
      59                 :            : /**
      60                 :            :  * Choose endpoint from ep arrays using usb_ep structure.
      61                 :            :  */
      62                 :            : static dwc_otg_pcd_ep_t *get_ep_from_handle(dwc_otg_pcd_t * pcd, void *handle)
      63                 :            : {
      64                 :            :         int i;
      65                 :          0 :         if (pcd->ep0.priv == handle) {
      66                 :          0 :                 return &pcd->ep0;
      67                 :            :         }
      68                 :          0 :         for (i = 0; i < MAX_EPS_CHANNELS - 1; i++) {
      69                 :          0 :                 if (pcd->in_ep[i].priv == handle)
      70                 :          0 :                         return &pcd->in_ep[i];
      71                 :          0 :                 if (pcd->out_ep[i].priv == handle)
      72                 :          0 :                         return &pcd->out_ep[i];
      73                 :            :         }
      74                 :            : 
      75                 :            :         return NULL;
      76                 :            : }
      77                 :            : 
      78                 :            : /**
      79                 :            :  * This function completes a request.  It call's the request call back.
      80                 :            :  */
      81                 :          0 : void dwc_otg_request_done(dwc_otg_pcd_ep_t * ep, dwc_otg_pcd_request_t * req,
      82                 :            :                           int32_t status)
      83                 :            : {
      84                 :          0 :         unsigned stopped = ep->stopped;
      85                 :            : 
      86                 :            :         DWC_DEBUGPL(DBG_PCDV, "%s(ep %p req %p)\n", __func__, ep, req);
      87                 :          0 :         DWC_CIRCLEQ_REMOVE_INIT(&ep->queue, req, queue_entry);
      88                 :            : 
      89                 :            :         /* don't modify queue heads during completion callback */
      90                 :          0 :         ep->stopped = 1;
      91                 :            :         /* spin_unlock/spin_lock now done in fops->complete() */
      92                 :          0 :         ep->pcd->fops->complete(ep->pcd, ep->priv, req->priv, status,
      93                 :            :                                 req->actual);
      94                 :            : 
      95                 :          0 :         if (ep->pcd->request_pending > 0) {
      96                 :          0 :                 --ep->pcd->request_pending;
      97                 :            :         }
      98                 :            : 
      99                 :          0 :         ep->stopped = stopped;
     100                 :          0 :         DWC_FREE(req);
     101                 :          0 : }
     102                 :            : 
     103                 :            : /**
     104                 :            :  * This function terminates all the requsts in the EP request queue.
     105                 :            :  */
     106                 :          0 : void dwc_otg_request_nuke(dwc_otg_pcd_ep_t * ep)
     107                 :            : {
     108                 :            :         dwc_otg_pcd_request_t *req;
     109                 :            : 
     110                 :          0 :         ep->stopped = 1;
     111                 :            : 
     112                 :            :         /* called with irqs blocked?? */
     113                 :          0 :         while (!DWC_CIRCLEQ_EMPTY(&ep->queue)) {
     114                 :            :                 req = DWC_CIRCLEQ_FIRST(&ep->queue);
     115                 :          0 :                 dwc_otg_request_done(ep, req, -DWC_E_SHUTDOWN);
     116                 :            :         }
     117                 :          0 : }
     118                 :            : 
     119                 :          3 : void dwc_otg_pcd_start(dwc_otg_pcd_t * pcd,
     120                 :            :                        const struct dwc_otg_pcd_function_ops *fops)
     121                 :            : {
     122                 :          3 :         pcd->fops = fops;
     123                 :          3 : }
     124                 :            : 
     125                 :            : /**
     126                 :            :  * PCD Callback function for initializing the PCD when switching to
     127                 :            :  * device mode.
     128                 :            :  *
     129                 :            :  * @param p void pointer to the <code>dwc_otg_pcd_t</code>
     130                 :            :  */
     131                 :          0 : static int32_t dwc_otg_pcd_start_cb(void *p)
     132                 :            : {
     133                 :            :         dwc_otg_pcd_t *pcd = (dwc_otg_pcd_t *) p;
     134                 :          0 :         dwc_otg_core_if_t *core_if = GET_CORE_IF(pcd);
     135                 :            : 
     136                 :            :         /*
     137                 :            :          * Initialized the Core for Device mode.
     138                 :            :          */
     139                 :          0 :         if (dwc_otg_is_device_mode(core_if)) {
     140                 :          0 :                 dwc_otg_core_dev_init(core_if);
     141                 :            :                 /* Set core_if's lock pointer to the pcd->lock */
     142                 :          0 :                 core_if->lock = pcd->lock;
     143                 :            :         }
     144                 :          0 :         return 1;
     145                 :            : }
     146                 :            : 
     147                 :            : /** CFI-specific buffer allocation function for EP */
     148                 :            : #ifdef DWC_UTE_CFI
     149                 :            : uint8_t *cfiw_ep_alloc_buffer(dwc_otg_pcd_t * pcd, void *pep, dwc_dma_t * addr,
     150                 :            :                               size_t buflen, int flags)
     151                 :            : {
     152                 :            :         dwc_otg_pcd_ep_t *ep;
     153                 :            :         ep = get_ep_from_handle(pcd, pep);
     154                 :            :         if (!ep) {
     155                 :            :                 DWC_WARN("bad ep\n");
     156                 :            :                 return -DWC_E_INVALID;
     157                 :            :         }
     158                 :            : 
     159                 :            :         return pcd->cfi->ops.ep_alloc_buf(pcd->cfi, pcd, ep, addr, buflen,
     160                 :            :                                           flags);
     161                 :            : }
     162                 :            : #else
     163                 :            : uint8_t *cfiw_ep_alloc_buffer(dwc_otg_pcd_t * pcd, void *pep, dwc_dma_t * addr,
     164                 :            :                               size_t buflen, int flags);
     165                 :            : #endif
     166                 :            : 
     167                 :            : /**
     168                 :            :  * PCD Callback function for notifying the PCD when resuming from
     169                 :            :  * suspend.
     170                 :            :  *
     171                 :            :  * @param p void pointer to the <code>dwc_otg_pcd_t</code>
     172                 :            :  */
     173                 :          0 : static int32_t dwc_otg_pcd_resume_cb(void *p)
     174                 :            : {
     175                 :            :         dwc_otg_pcd_t *pcd = (dwc_otg_pcd_t *) p;
     176                 :            : 
     177                 :          0 :         if (pcd->fops->resume) {
     178                 :          0 :                 pcd->fops->resume(pcd);
     179                 :            :         }
     180                 :            : 
     181                 :            :         /* Stop the SRP timeout timer. */
     182                 :          0 :         if ((GET_CORE_IF(pcd)->core_params->phy_type != DWC_PHY_TYPE_PARAM_FS)
     183                 :          0 :             || (!GET_CORE_IF(pcd)->core_params->i2c_enable)) {
     184                 :          0 :                 if (GET_CORE_IF(pcd)->srp_timer_started) {
     185                 :          0 :                         GET_CORE_IF(pcd)->srp_timer_started = 0;
     186                 :          0 :                         DWC_TIMER_CANCEL(GET_CORE_IF(pcd)->srp_timer);
     187                 :            :                 }
     188                 :            :         }
     189                 :          0 :         return 1;
     190                 :            : }
     191                 :            : 
     192                 :            : /**
     193                 :            :  * PCD Callback function for notifying the PCD device is suspended.
     194                 :            :  *
     195                 :            :  * @param p void pointer to the <code>dwc_otg_pcd_t</code>
     196                 :            :  */
     197                 :          0 : static int32_t dwc_otg_pcd_suspend_cb(void *p)
     198                 :            : {
     199                 :            :         dwc_otg_pcd_t *pcd = (dwc_otg_pcd_t *) p;
     200                 :            : 
     201                 :          0 :         if (pcd->fops->suspend) {
     202                 :          0 :                 DWC_SPINUNLOCK(pcd->lock);
     203                 :          0 :                 pcd->fops->suspend(pcd);
     204                 :          0 :                 DWC_SPINLOCK(pcd->lock);
     205                 :            :         }
     206                 :            : 
     207                 :          0 :         return 1;
     208                 :            : }
     209                 :            : 
     210                 :            : /**
     211                 :            :  * PCD Callback function for stopping the PCD when switching to Host
     212                 :            :  * mode.
     213                 :            :  *
     214                 :            :  * @param p void pointer to the <code>dwc_otg_pcd_t</code>
     215                 :            :  */
     216                 :          0 : static int32_t dwc_otg_pcd_stop_cb(void *p)
     217                 :            : {
     218                 :            :         dwc_otg_pcd_t *pcd = (dwc_otg_pcd_t *) p;
     219                 :            :         extern void dwc_otg_pcd_stop(dwc_otg_pcd_t * _pcd);
     220                 :            : 
     221                 :          0 :         dwc_otg_pcd_stop(pcd);
     222                 :          0 :         return 1;
     223                 :            : }
     224                 :            : 
     225                 :            : /**
     226                 :            :  * PCD Callback structure for handling mode switching.
     227                 :            :  */
     228                 :            : static dwc_otg_cil_callbacks_t pcd_callbacks = {
     229                 :            :         .start = dwc_otg_pcd_start_cb,
     230                 :            :         .stop = dwc_otg_pcd_stop_cb,
     231                 :            :         .suspend = dwc_otg_pcd_suspend_cb,
     232                 :            :         .resume_wakeup = dwc_otg_pcd_resume_cb,
     233                 :            :         .p = 0,                 /* Set at registration */
     234                 :            : };
     235                 :            : 
     236                 :            : /**
     237                 :            :  * This function allocates a DMA Descriptor chain for the Endpoint
     238                 :            :  * buffer to be used for a transfer to/from the specified endpoint.
     239                 :            :  */
     240                 :          0 : dwc_otg_dev_dma_desc_t *dwc_otg_ep_alloc_desc_chain(struct device *dev,
     241                 :            :                                                     dwc_dma_t * dma_desc_addr,
     242                 :            :                                                     uint32_t count)
     243                 :            : {
     244                 :          0 :         return DWC_DMA_ALLOC_ATOMIC(dev, count * sizeof(dwc_otg_dev_dma_desc_t),
     245                 :            :                                                         dma_desc_addr);
     246                 :            : }
     247                 :            : 
     248                 :            : /**
     249                 :            :  * This function frees a DMA Descriptor chain that was allocated by ep_alloc_desc.
     250                 :            :  */
     251                 :          0 : void dwc_otg_ep_free_desc_chain(struct device *dev,
     252                 :            :                                 dwc_otg_dev_dma_desc_t * desc_addr,
     253                 :            :                                 uint32_t dma_desc_addr, uint32_t count)
     254                 :            : {
     255                 :          0 :         DWC_DMA_FREE(dev, count * sizeof(dwc_otg_dev_dma_desc_t), desc_addr,
     256                 :            :                      dma_desc_addr);
     257                 :          0 : }
     258                 :            : 
     259                 :            : #ifdef DWC_EN_ISOC
     260                 :            : 
     261                 :            : /**
     262                 :            :  * This function initializes a descriptor chain for Isochronous transfer
     263                 :            :  *
     264                 :            :  * @param core_if Programming view of DWC_otg controller.
     265                 :            :  * @param dwc_ep The EP to start the transfer on.
     266                 :            :  *
     267                 :            :  */
     268                 :            : void dwc_otg_iso_ep_start_ddma_transfer(dwc_otg_core_if_t * core_if,
     269                 :            :                                         dwc_ep_t * dwc_ep)
     270                 :            : {
     271                 :            : 
     272                 :            :         dsts_data_t dsts = {.d32 = 0 };
     273                 :            :         depctl_data_t depctl = {.d32 = 0 };
     274                 :            :         volatile uint32_t *addr;
     275                 :            :         int i, j;
     276                 :            :         uint32_t len;
     277                 :            : 
     278                 :            :         if (dwc_ep->is_in)
     279                 :            :                 dwc_ep->desc_cnt = dwc_ep->buf_proc_intrvl / dwc_ep->bInterval;
     280                 :            :         else
     281                 :            :                 dwc_ep->desc_cnt =
     282                 :            :                     dwc_ep->buf_proc_intrvl * dwc_ep->pkt_per_frm /
     283                 :            :                     dwc_ep->bInterval;
     284                 :            : 
     285                 :            :         /** Allocate descriptors for double buffering */
     286                 :            :         dwc_ep->iso_desc_addr =
     287                 :            :             dwc_otg_ep_alloc_desc_chain(&dwc_ep->iso_dma_desc_addr,
     288                 :            :                                         dwc_ep->desc_cnt * 2);
     289                 :            :         if (dwc_ep->desc_addr) {
     290                 :            :                 DWC_WARN("%s, can't allocate DMA descriptor chain\n", __func__);
     291                 :            :                 return;
     292                 :            :         }
     293                 :            : 
     294                 :            :         dsts.d32 = DWC_READ_REG32(&core_if->dev_if->dev_global_regs->dsts);
     295                 :            : 
     296                 :            :         /** ISO OUT EP */
     297                 :            :         if (dwc_ep->is_in == 0) {
     298                 :            :                 dev_dma_desc_sts_t sts = {.d32 = 0 };
     299                 :            :                 dwc_otg_dev_dma_desc_t *dma_desc = dwc_ep->iso_desc_addr;
     300                 :            :                 dma_addr_t dma_ad;
     301                 :            :                 uint32_t data_per_desc;
     302                 :            :                 dwc_otg_dev_out_ep_regs_t *out_regs =
     303                 :            :                     core_if->dev_if->out_ep_regs[dwc_ep->num];
     304                 :            :                 int offset;
     305                 :            : 
     306                 :            :                 addr = &core_if->dev_if->out_ep_regs[dwc_ep->num]->doepctl;
     307                 :            :                 dma_ad = (dma_addr_t) DWC_READ_REG32(&(out_regs->doepdma));
     308                 :            : 
     309                 :            :                 /** Buffer 0 descriptors setup */
     310                 :            :                 dma_ad = dwc_ep->dma_addr0;
     311                 :            : 
     312                 :            :                 sts.b_iso_out.bs = BS_HOST_READY;
     313                 :            :                 sts.b_iso_out.rxsts = 0;
     314                 :            :                 sts.b_iso_out.l = 0;
     315                 :            :                 sts.b_iso_out.sp = 0;
     316                 :            :                 sts.b_iso_out.ioc = 0;
     317                 :            :                 sts.b_iso_out.pid = 0;
     318                 :            :                 sts.b_iso_out.framenum = 0;
     319                 :            : 
     320                 :            :                 offset = 0;
     321                 :            :                 for (i = 0; i < dwc_ep->desc_cnt - dwc_ep->pkt_per_frm;
     322                 :            :                      i += dwc_ep->pkt_per_frm) {
     323                 :            : 
     324                 :            :                         for (j = 0; j < dwc_ep->pkt_per_frm; ++j) {
     325                 :            :                                 uint32_t len = (j + 1) * dwc_ep->maxpacket;
     326                 :            :                                 if (len > dwc_ep->data_per_frame)
     327                 :            :                                         data_per_desc =
     328                 :            :                                             dwc_ep->data_per_frame -
     329                 :            :                                             j * dwc_ep->maxpacket;
     330                 :            :                                 else
     331                 :            :                                         data_per_desc = dwc_ep->maxpacket;
     332                 :            :                                 len = data_per_desc % 4;
     333                 :            :                                 if (len)
     334                 :            :                                         data_per_desc += 4 - len;
     335                 :            : 
     336                 :            :                                 sts.b_iso_out.rxbytes = data_per_desc;
     337                 :            :                                 dma_desc->buf = dma_ad;
     338                 :            :                                 dma_desc->status.d32 = sts.d32;
     339                 :            : 
     340                 :            :                                 offset += data_per_desc;
     341                 :            :                                 dma_desc++;
     342                 :            :                                 dma_ad += data_per_desc;
     343                 :            :                         }
     344                 :            :                 }
     345                 :            : 
     346                 :            :                 for (j = 0; j < dwc_ep->pkt_per_frm - 1; ++j) {
     347                 :            :                         uint32_t len = (j + 1) * dwc_ep->maxpacket;
     348                 :            :                         if (len > dwc_ep->data_per_frame)
     349                 :            :                                 data_per_desc =
     350                 :            :                                     dwc_ep->data_per_frame -
     351                 :            :                                     j * dwc_ep->maxpacket;
     352                 :            :                         else
     353                 :            :                                 data_per_desc = dwc_ep->maxpacket;
     354                 :            :                         len = data_per_desc % 4;
     355                 :            :                         if (len)
     356                 :            :                                 data_per_desc += 4 - len;
     357                 :            :                         sts.b_iso_out.rxbytes = data_per_desc;
     358                 :            :                         dma_desc->buf = dma_ad;
     359                 :            :                         dma_desc->status.d32 = sts.d32;
     360                 :            : 
     361                 :            :                         offset += data_per_desc;
     362                 :            :                         dma_desc++;
     363                 :            :                         dma_ad += data_per_desc;
     364                 :            :                 }
     365                 :            : 
     366                 :            :                 sts.b_iso_out.ioc = 1;
     367                 :            :                 len = (j + 1) * dwc_ep->maxpacket;
     368                 :            :                 if (len > dwc_ep->data_per_frame)
     369                 :            :                         data_per_desc =
     370                 :            :                             dwc_ep->data_per_frame - j * dwc_ep->maxpacket;
     371                 :            :                 else
     372                 :            :                         data_per_desc = dwc_ep->maxpacket;
     373                 :            :                 len = data_per_desc % 4;
     374                 :            :                 if (len)
     375                 :            :                         data_per_desc += 4 - len;
     376                 :            :                 sts.b_iso_out.rxbytes = data_per_desc;
     377                 :            : 
     378                 :            :                 dma_desc->buf = dma_ad;
     379                 :            :                 dma_desc->status.d32 = sts.d32;
     380                 :            :                 dma_desc++;
     381                 :            : 
     382                 :            :                 /** Buffer 1 descriptors setup */
     383                 :            :                 sts.b_iso_out.ioc = 0;
     384                 :            :                 dma_ad = dwc_ep->dma_addr1;
     385                 :            : 
     386                 :            :                 offset = 0;
     387                 :            :                 for (i = 0; i < dwc_ep->desc_cnt - dwc_ep->pkt_per_frm;
     388                 :            :                      i += dwc_ep->pkt_per_frm) {
     389                 :            :                         for (j = 0; j < dwc_ep->pkt_per_frm; ++j) {
     390                 :            :                                 uint32_t len = (j + 1) * dwc_ep->maxpacket;
     391                 :            :                                 if (len > dwc_ep->data_per_frame)
     392                 :            :                                         data_per_desc =
     393                 :            :                                             dwc_ep->data_per_frame -
     394                 :            :                                             j * dwc_ep->maxpacket;
     395                 :            :                                 else
     396                 :            :                                         data_per_desc = dwc_ep->maxpacket;
     397                 :            :                                 len = data_per_desc % 4;
     398                 :            :                                 if (len)
     399                 :            :                                         data_per_desc += 4 - len;
     400                 :            : 
     401                 :            :                                 data_per_desc =
     402                 :            :                                     sts.b_iso_out.rxbytes = data_per_desc;
     403                 :            :                                 dma_desc->buf = dma_ad;
     404                 :            :                                 dma_desc->status.d32 = sts.d32;
     405                 :            : 
     406                 :            :                                 offset += data_per_desc;
     407                 :            :                                 dma_desc++;
     408                 :            :                                 dma_ad += data_per_desc;
     409                 :            :                         }
     410                 :            :                 }
     411                 :            :                 for (j = 0; j < dwc_ep->pkt_per_frm - 1; ++j) {
     412                 :            :                         data_per_desc =
     413                 :            :                             ((j + 1) * dwc_ep->maxpacket >
     414                 :            :                              dwc_ep->data_per_frame) ? dwc_ep->data_per_frame -
     415                 :            :                             j * dwc_ep->maxpacket : dwc_ep->maxpacket;
     416                 :            :                         data_per_desc +=
     417                 :            :                             (data_per_desc % 4) ? (4 - data_per_desc % 4) : 0;
     418                 :            :                         sts.b_iso_out.rxbytes = data_per_desc;
     419                 :            :                         dma_desc->buf = dma_ad;
     420                 :            :                         dma_desc->status.d32 = sts.d32;
     421                 :            : 
     422                 :            :                         offset += data_per_desc;
     423                 :            :                         dma_desc++;
     424                 :            :                         dma_ad += data_per_desc;
     425                 :            :                 }
     426                 :            : 
     427                 :            :                 sts.b_iso_out.ioc = 1;
     428                 :            :                 sts.b_iso_out.l = 1;
     429                 :            :                 data_per_desc =
     430                 :            :                     ((j + 1) * dwc_ep->maxpacket >
     431                 :            :                      dwc_ep->data_per_frame) ? dwc_ep->data_per_frame -
     432                 :            :                     j * dwc_ep->maxpacket : dwc_ep->maxpacket;
     433                 :            :                 data_per_desc +=
     434                 :            :                     (data_per_desc % 4) ? (4 - data_per_desc % 4) : 0;
     435                 :            :                 sts.b_iso_out.rxbytes = data_per_desc;
     436                 :            : 
     437                 :            :                 dma_desc->buf = dma_ad;
     438                 :            :                 dma_desc->status.d32 = sts.d32;
     439                 :            : 
     440                 :            :                 dwc_ep->next_frame = 0;
     441                 :            : 
     442                 :            :                 /** Write dma_ad into DOEPDMA register */
     443                 :            :                 DWC_WRITE_REG32(&(out_regs->doepdma),
     444                 :            :                                 (uint32_t) dwc_ep->iso_dma_desc_addr);
     445                 :            : 
     446                 :            :         }
     447                 :            :         /** ISO IN EP */
     448                 :            :         else {
     449                 :            :                 dev_dma_desc_sts_t sts = {.d32 = 0 };
     450                 :            :                 dwc_otg_dev_dma_desc_t *dma_desc = dwc_ep->iso_desc_addr;
     451                 :            :                 dma_addr_t dma_ad;
     452                 :            :                 dwc_otg_dev_in_ep_regs_t *in_regs =
     453                 :            :                     core_if->dev_if->in_ep_regs[dwc_ep->num];
     454                 :            :                 unsigned int frmnumber;
     455                 :            :                 fifosize_data_t txfifosize, rxfifosize;
     456                 :            : 
     457                 :            :                 txfifosize.d32 =
     458                 :            :                     DWC_READ_REG32(&core_if->dev_if->in_ep_regs[dwc_ep->num]->
     459                 :            :                                    dtxfsts);
     460                 :            :                 rxfifosize.d32 =
     461                 :            :                     DWC_READ_REG32(&core_if->core_global_regs->grxfsiz);
     462                 :            : 
     463                 :            :                 addr = &core_if->dev_if->in_ep_regs[dwc_ep->num]->diepctl;
     464                 :            : 
     465                 :            :                 dma_ad = dwc_ep->dma_addr0;
     466                 :            : 
     467                 :            :                 dsts.d32 =
     468                 :            :                     DWC_READ_REG32(&core_if->dev_if->dev_global_regs->dsts);
     469                 :            : 
     470                 :            :                 sts.b_iso_in.bs = BS_HOST_READY;
     471                 :            :                 sts.b_iso_in.txsts = 0;
     472                 :            :                 sts.b_iso_in.sp =
     473                 :            :                     (dwc_ep->data_per_frame % dwc_ep->maxpacket) ? 1 : 0;
     474                 :            :                 sts.b_iso_in.ioc = 0;
     475                 :            :                 sts.b_iso_in.pid = dwc_ep->pkt_per_frm;
     476                 :            : 
     477                 :            :                 frmnumber = dwc_ep->next_frame;
     478                 :            : 
     479                 :            :                 sts.b_iso_in.framenum = frmnumber;
     480                 :            :                 sts.b_iso_in.txbytes = dwc_ep->data_per_frame;
     481                 :            :                 sts.b_iso_in.l = 0;
     482                 :            : 
     483                 :            :                 /** Buffer 0 descriptors setup */
     484                 :            :                 for (i = 0; i < dwc_ep->desc_cnt - 1; i++) {
     485                 :            :                         dma_desc->buf = dma_ad;
     486                 :            :                         dma_desc->status.d32 = sts.d32;
     487                 :            :                         dma_desc++;
     488                 :            : 
     489                 :            :                         dma_ad += dwc_ep->data_per_frame;
     490                 :            :                         sts.b_iso_in.framenum += dwc_ep->bInterval;
     491                 :            :                 }
     492                 :            : 
     493                 :            :                 sts.b_iso_in.ioc = 1;
     494                 :            :                 dma_desc->buf = dma_ad;
     495                 :            :                 dma_desc->status.d32 = sts.d32;
     496                 :            :                 ++dma_desc;
     497                 :            : 
     498                 :            :                 /** Buffer 1 descriptors setup */
     499                 :            :                 sts.b_iso_in.ioc = 0;
     500                 :            :                 dma_ad = dwc_ep->dma_addr1;
     501                 :            : 
     502                 :            :                 for (i = 0; i < dwc_ep->desc_cnt - dwc_ep->pkt_per_frm;
     503                 :            :                      i += dwc_ep->pkt_per_frm) {
     504                 :            :                         dma_desc->buf = dma_ad;
     505                 :            :                         dma_desc->status.d32 = sts.d32;
     506                 :            :                         dma_desc++;
     507                 :            : 
     508                 :            :                         dma_ad += dwc_ep->data_per_frame;
     509                 :            :                         sts.b_iso_in.framenum += dwc_ep->bInterval;
     510                 :            : 
     511                 :            :                         sts.b_iso_in.ioc = 0;
     512                 :            :                 }
     513                 :            :                 sts.b_iso_in.ioc = 1;
     514                 :            :                 sts.b_iso_in.l = 1;
     515                 :            : 
     516                 :            :                 dma_desc->buf = dma_ad;
     517                 :            :                 dma_desc->status.d32 = sts.d32;
     518                 :            : 
     519                 :            :                 dwc_ep->next_frame = sts.b_iso_in.framenum + dwc_ep->bInterval;
     520                 :            : 
     521                 :            :                 /** Write dma_ad into diepdma register */
     522                 :            :                 DWC_WRITE_REG32(&(in_regs->diepdma),
     523                 :            :                                 (uint32_t) dwc_ep->iso_dma_desc_addr);
     524                 :            :         }
     525                 :            :         /** Enable endpoint, clear nak  */
     526                 :            :         depctl.d32 = 0;
     527                 :            :         depctl.b.epena = 1;
     528                 :            :         depctl.b.usbactep = 1;
     529                 :            :         depctl.b.cnak = 1;
     530                 :            : 
     531                 :            :         DWC_MODIFY_REG32(addr, depctl.d32, depctl.d32);
     532                 :            :         depctl.d32 = DWC_READ_REG32(addr);
     533                 :            : }
     534                 :            : 
     535                 :            : /**
     536                 :            :  * This function initializes a descriptor chain for Isochronous transfer
     537                 :            :  *
     538                 :            :  * @param core_if Programming view of DWC_otg controller.
     539                 :            :  * @param ep The EP to start the transfer on.
     540                 :            :  *
     541                 :            :  */
     542                 :            : void dwc_otg_iso_ep_start_buf_transfer(dwc_otg_core_if_t * core_if,
     543                 :            :                                        dwc_ep_t * ep)
     544                 :            : {
     545                 :            :         depctl_data_t depctl = {.d32 = 0 };
     546                 :            :         volatile uint32_t *addr;
     547                 :            : 
     548                 :            :         if (ep->is_in) {
     549                 :            :                 addr = &core_if->dev_if->in_ep_regs[ep->num]->diepctl;
     550                 :            :         } else {
     551                 :            :                 addr = &core_if->dev_if->out_ep_regs[ep->num]->doepctl;
     552                 :            :         }
     553                 :            : 
     554                 :            :         if (core_if->dma_enable == 0 || core_if->dma_desc_enable != 0) {
     555                 :            :                 return;
     556                 :            :         } else {
     557                 :            :                 deptsiz_data_t deptsiz = {.d32 = 0 };
     558                 :            : 
     559                 :            :                 ep->xfer_len =
     560                 :            :                     ep->data_per_frame * ep->buf_proc_intrvl / ep->bInterval;
     561                 :            :                 ep->pkt_cnt =
     562                 :            :                     (ep->xfer_len - 1 + ep->maxpacket) / ep->maxpacket;
     563                 :            :                 ep->xfer_count = 0;
     564                 :            :                 ep->xfer_buff =
     565                 :            :                     (ep->proc_buf_num) ? ep->xfer_buff1 : ep->xfer_buff0;
     566                 :            :                 ep->dma_addr =
     567                 :            :                     (ep->proc_buf_num) ? ep->dma_addr1 : ep->dma_addr0;
     568                 :            : 
     569                 :            :                 if (ep->is_in) {
     570                 :            :                         /* Program the transfer size and packet count
     571                 :            :                          *      as follows: xfersize = N * maxpacket +
     572                 :            :                          *      short_packet pktcnt = N + (short_packet
     573                 :            :                          *      exist ? 1 : 0)
     574                 :            :                          */
     575                 :            :                         deptsiz.b.mc = ep->pkt_per_frm;
     576                 :            :                         deptsiz.b.xfersize = ep->xfer_len;
     577                 :            :                         deptsiz.b.pktcnt =
     578                 :            :                             (ep->xfer_len - 1 + ep->maxpacket) / ep->maxpacket;
     579                 :            :                         DWC_WRITE_REG32(&core_if->dev_if->in_ep_regs[ep->num]->
     580                 :            :                                         dieptsiz, deptsiz.d32);
     581                 :            : 
     582                 :            :                         /* Write the DMA register */
     583                 :            :                         DWC_WRITE_REG32(&
     584                 :            :                                         (core_if->dev_if->in_ep_regs[ep->num]->
     585                 :            :                                          diepdma), (uint32_t) ep->dma_addr);
     586                 :            : 
     587                 :            :                 } else {
     588                 :            :                         deptsiz.b.pktcnt =
     589                 :            :                             (ep->xfer_len + (ep->maxpacket - 1)) /
     590                 :            :                             ep->maxpacket;
     591                 :            :                         deptsiz.b.xfersize = deptsiz.b.pktcnt * ep->maxpacket;
     592                 :            : 
     593                 :            :                         DWC_WRITE_REG32(&core_if->dev_if->out_ep_regs[ep->num]->
     594                 :            :                                         doeptsiz, deptsiz.d32);
     595                 :            : 
     596                 :            :                         /* Write the DMA register */
     597                 :            :                         DWC_WRITE_REG32(&
     598                 :            :                                         (core_if->dev_if->out_ep_regs[ep->num]->
     599                 :            :                                          doepdma), (uint32_t) ep->dma_addr);
     600                 :            : 
     601                 :            :                 }
     602                 :            :                 /** Enable endpoint, clear nak  */
     603                 :            :                 depctl.d32 = 0;
     604                 :            :                 depctl.b.epena = 1;
     605                 :            :                 depctl.b.cnak = 1;
     606                 :            : 
     607                 :            :                 DWC_MODIFY_REG32(addr, depctl.d32, depctl.d32);
     608                 :            :         }
     609                 :            : }
     610                 :            : 
     611                 :            : /**
     612                 :            :  * This function does the setup for a data transfer for an EP and
     613                 :            :  * starts the transfer. For an IN transfer, the packets will be
     614                 :            :  * loaded into the appropriate Tx FIFO in the ISR. For OUT transfers,
     615                 :            :  * the packets are unloaded from the Rx FIFO in the ISR.
     616                 :            :  *
     617                 :            :  * @param core_if Programming view of DWC_otg controller.
     618                 :            :  * @param ep The EP to start the transfer on.
     619                 :            :  */
     620                 :            : 
     621                 :            : static void dwc_otg_iso_ep_start_transfer(dwc_otg_core_if_t * core_if,
     622                 :            :                                           dwc_ep_t * ep)
     623                 :            : {
     624                 :            :         if (core_if->dma_enable) {
     625                 :            :                 if (core_if->dma_desc_enable) {
     626                 :            :                         if (ep->is_in) {
     627                 :            :                                 ep->desc_cnt = ep->pkt_cnt / ep->pkt_per_frm;
     628                 :            :                         } else {
     629                 :            :                                 ep->desc_cnt = ep->pkt_cnt;
     630                 :            :                         }
     631                 :            :                         dwc_otg_iso_ep_start_ddma_transfer(core_if, ep);
     632                 :            :                 } else {
     633                 :            :                         if (core_if->pti_enh_enable) {
     634                 :            :                                 dwc_otg_iso_ep_start_buf_transfer(core_if, ep);
     635                 :            :                         } else {
     636                 :            :                                 ep->cur_pkt_addr =
     637                 :            :                                     (ep->proc_buf_num) ? ep->xfer_buff1 : ep->
     638                 :            :                                     xfer_buff0;
     639                 :            :                                 ep->cur_pkt_dma_addr =
     640                 :            :                                     (ep->proc_buf_num) ? ep->dma_addr1 : ep->
     641                 :            :                                     dma_addr0;
     642                 :            :                                 dwc_otg_iso_ep_start_frm_transfer(core_if, ep);
     643                 :            :                         }
     644                 :            :                 }
     645                 :            :         } else {
     646                 :            :                 ep->cur_pkt_addr =
     647                 :            :                     (ep->proc_buf_num) ? ep->xfer_buff1 : ep->xfer_buff0;
     648                 :            :                 ep->cur_pkt_dma_addr =
     649                 :            :                     (ep->proc_buf_num) ? ep->dma_addr1 : ep->dma_addr0;
     650                 :            :                 dwc_otg_iso_ep_start_frm_transfer(core_if, ep);
     651                 :            :         }
     652                 :            : }
     653                 :            : 
     654                 :            : /**
     655                 :            :  * This function stops transfer for an EP and
     656                 :            :  * resets the ep's variables.
     657                 :            :  *
     658                 :            :  * @param core_if Programming view of DWC_otg controller.
     659                 :            :  * @param ep The EP to start the transfer on.
     660                 :            :  */
     661                 :            : 
     662                 :            : void dwc_otg_iso_ep_stop_transfer(dwc_otg_core_if_t * core_if, dwc_ep_t * ep)
     663                 :            : {
     664                 :            :         depctl_data_t depctl = {.d32 = 0 };
     665                 :            :         volatile uint32_t *addr;
     666                 :            : 
     667                 :            :         if (ep->is_in == 1) {
     668                 :            :                 addr = &core_if->dev_if->in_ep_regs[ep->num]->diepctl;
     669                 :            :         } else {
     670                 :            :                 addr = &core_if->dev_if->out_ep_regs[ep->num]->doepctl;
     671                 :            :         }
     672                 :            : 
     673                 :            :         /* disable the ep */
     674                 :            :         depctl.d32 = DWC_READ_REG32(addr);
     675                 :            : 
     676                 :            :         depctl.b.epdis = 1;
     677                 :            :         depctl.b.snak = 1;
     678                 :            : 
     679                 :            :         DWC_WRITE_REG32(addr, depctl.d32);
     680                 :            : 
     681                 :            :         if (core_if->dma_desc_enable &&
     682                 :            :             ep->iso_desc_addr && ep->iso_dma_desc_addr) {
     683                 :            :                 dwc_otg_ep_free_desc_chain(ep->iso_desc_addr,
     684                 :            :                                            ep->iso_dma_desc_addr,
     685                 :            :                                            ep->desc_cnt * 2);
     686                 :            :         }
     687                 :            : 
     688                 :            :         /* reset varibales */
     689                 :            :         ep->dma_addr0 = 0;
     690                 :            :         ep->dma_addr1 = 0;
     691                 :            :         ep->xfer_buff0 = 0;
     692                 :            :         ep->xfer_buff1 = 0;
     693                 :            :         ep->data_per_frame = 0;
     694                 :            :         ep->data_pattern_frame = 0;
     695                 :            :         ep->sync_frame = 0;
     696                 :            :         ep->buf_proc_intrvl = 0;
     697                 :            :         ep->bInterval = 0;
     698                 :            :         ep->proc_buf_num = 0;
     699                 :            :         ep->pkt_per_frm = 0;
     700                 :            :         ep->pkt_per_frm = 0;
     701                 :            :         ep->desc_cnt = 0;
     702                 :            :         ep->iso_desc_addr = 0;
     703                 :            :         ep->iso_dma_desc_addr = 0;
     704                 :            : }
     705                 :            : 
     706                 :            : int dwc_otg_pcd_iso_ep_start(dwc_otg_pcd_t * pcd, void *ep_handle,
     707                 :            :                              uint8_t * buf0, uint8_t * buf1, dwc_dma_t dma0,
     708                 :            :                              dwc_dma_t dma1, int sync_frame, int dp_frame,
     709                 :            :                              int data_per_frame, int start_frame,
     710                 :            :                              int buf_proc_intrvl, void *req_handle,
     711                 :            :                              int atomic_alloc)
     712                 :            : {
     713                 :            :         dwc_otg_pcd_ep_t *ep;
     714                 :            :         dwc_irqflags_t flags = 0;
     715                 :            :         dwc_ep_t *dwc_ep;
     716                 :            :         int32_t frm_data;
     717                 :            :         dsts_data_t dsts;
     718                 :            :         dwc_otg_core_if_t *core_if;
     719                 :            : 
     720                 :            :         ep = get_ep_from_handle(pcd, ep_handle);
     721                 :            : 
     722                 :            :         if (!ep || !ep->desc || ep->dwc_ep.num == 0) {
     723                 :            :                 DWC_WARN("bad ep\n");
     724                 :            :                 return -DWC_E_INVALID;
     725                 :            :         }
     726                 :            : 
     727                 :            :         DWC_SPINLOCK_IRQSAVE(pcd->lock, &flags);
     728                 :            :         core_if = GET_CORE_IF(pcd);
     729                 :            :         dwc_ep = &ep->dwc_ep;
     730                 :            : 
     731                 :            :         if (ep->iso_req_handle) {
     732                 :            :                 DWC_WARN("ISO request in progress\n");
     733                 :            :         }
     734                 :            : 
     735                 :            :         dwc_ep->dma_addr0 = dma0;
     736                 :            :         dwc_ep->dma_addr1 = dma1;
     737                 :            : 
     738                 :            :         dwc_ep->xfer_buff0 = buf0;
     739                 :            :         dwc_ep->xfer_buff1 = buf1;
     740                 :            : 
     741                 :            :         dwc_ep->data_per_frame = data_per_frame;
     742                 :            : 
     743                 :            :         /** @todo - pattern data support is to be implemented in the future */
     744                 :            :         dwc_ep->data_pattern_frame = dp_frame;
     745                 :            :         dwc_ep->sync_frame = sync_frame;
     746                 :            : 
     747                 :            :         dwc_ep->buf_proc_intrvl = buf_proc_intrvl;
     748                 :            : 
     749                 :            :         dwc_ep->bInterval = 1 << (ep->desc->bInterval - 1);
     750                 :            : 
     751                 :            :         dwc_ep->proc_buf_num = 0;
     752                 :            : 
     753                 :            :         dwc_ep->pkt_per_frm = 0;
     754                 :            :         frm_data = ep->dwc_ep.data_per_frame;
     755                 :            :         while (frm_data > 0) {
     756                 :            :                 dwc_ep->pkt_per_frm++;
     757                 :            :                 frm_data -= ep->dwc_ep.maxpacket;
     758                 :            :         }
     759                 :            : 
     760                 :            :         dsts.d32 = DWC_READ_REG32(&core_if->dev_if->dev_global_regs->dsts);
     761                 :            : 
     762                 :            :         if (start_frame == -1) {
     763                 :            :                 dwc_ep->next_frame = dsts.b.soffn + 1;
     764                 :            :                 if (dwc_ep->bInterval != 1) {
     765                 :            :                         dwc_ep->next_frame =
     766                 :            :                             dwc_ep->next_frame + (dwc_ep->bInterval - 1 -
     767                 :            :                                                   dwc_ep->next_frame %
     768                 :            :                                                   dwc_ep->bInterval);
     769                 :            :                 }
     770                 :            :         } else {
     771                 :            :                 dwc_ep->next_frame = start_frame;
     772                 :            :         }
     773                 :            : 
     774                 :            :         if (!core_if->pti_enh_enable) {
     775                 :            :                 dwc_ep->pkt_cnt =
     776                 :            :                     dwc_ep->buf_proc_intrvl * dwc_ep->pkt_per_frm /
     777                 :            :                     dwc_ep->bInterval;
     778                 :            :         } else {
     779                 :            :                 dwc_ep->pkt_cnt =
     780                 :            :                     (dwc_ep->data_per_frame *
     781                 :            :                      (dwc_ep->buf_proc_intrvl / dwc_ep->bInterval)
     782                 :            :                      - 1 + dwc_ep->maxpacket) / dwc_ep->maxpacket;
     783                 :            :         }
     784                 :            : 
     785                 :            :         if (core_if->dma_desc_enable) {
     786                 :            :                 dwc_ep->desc_cnt =
     787                 :            :                     dwc_ep->buf_proc_intrvl * dwc_ep->pkt_per_frm /
     788                 :            :                     dwc_ep->bInterval;
     789                 :            :         }
     790                 :            : 
     791                 :            :         if (atomic_alloc) {
     792                 :            :                 dwc_ep->pkt_info =
     793                 :            :                     DWC_ALLOC_ATOMIC(sizeof(iso_pkt_info_t) * dwc_ep->pkt_cnt);
     794                 :            :         } else {
     795                 :            :                 dwc_ep->pkt_info =
     796                 :            :                     DWC_ALLOC(sizeof(iso_pkt_info_t) * dwc_ep->pkt_cnt);
     797                 :            :         }
     798                 :            :         if (!dwc_ep->pkt_info) {
     799                 :            :                 DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
     800                 :            :                 return -DWC_E_NO_MEMORY;
     801                 :            :         }
     802                 :            :         if (core_if->pti_enh_enable) {
     803                 :            :                 dwc_memset(dwc_ep->pkt_info, 0,
     804                 :            :                            sizeof(iso_pkt_info_t) * dwc_ep->pkt_cnt);
     805                 :            :         }
     806                 :            : 
     807                 :            :         dwc_ep->cur_pkt = 0;
     808                 :            :         ep->iso_req_handle = req_handle;
     809                 :            : 
     810                 :            :         DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
     811                 :            :         dwc_otg_iso_ep_start_transfer(core_if, dwc_ep);
     812                 :            :         return 0;
     813                 :            : }
     814                 :            : 
     815                 :            : int dwc_otg_pcd_iso_ep_stop(dwc_otg_pcd_t * pcd, void *ep_handle,
     816                 :            :                             void *req_handle)
     817                 :            : {
     818                 :            :         dwc_irqflags_t flags = 0;
     819                 :            :         dwc_otg_pcd_ep_t *ep;
     820                 :            :         dwc_ep_t *dwc_ep;
     821                 :            : 
     822                 :            :         ep = get_ep_from_handle(pcd, ep_handle);
     823                 :            :         if (!ep || !ep->desc || ep->dwc_ep.num == 0) {
     824                 :            :                 DWC_WARN("bad ep\n");
     825                 :            :                 return -DWC_E_INVALID;
     826                 :            :         }
     827                 :            :         dwc_ep = &ep->dwc_ep;
     828                 :            : 
     829                 :            :         dwc_otg_iso_ep_stop_transfer(GET_CORE_IF(pcd), dwc_ep);
     830                 :            : 
     831                 :            :         DWC_FREE(dwc_ep->pkt_info);
     832                 :            :         DWC_SPINLOCK_IRQSAVE(pcd->lock, &flags);
     833                 :            :         if (ep->iso_req_handle != req_handle) {
     834                 :            :                 DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
     835                 :            :                 return -DWC_E_INVALID;
     836                 :            :         }
     837                 :            : 
     838                 :            :         DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
     839                 :            : 
     840                 :            :         ep->iso_req_handle = 0;
     841                 :            :         return 0;
     842                 :            : }
     843                 :            : 
     844                 :            : /**
     845                 :            :  * This function is used for perodical data exchnage between PCD and gadget drivers.
     846                 :            :  * for Isochronous EPs
     847                 :            :  *
     848                 :            :  *      - Every time a sync period completes this function is called to
     849                 :            :  *        perform data exchange between PCD and gadget
     850                 :            :  */
     851                 :            : void dwc_otg_iso_buffer_done(dwc_otg_pcd_t * pcd, dwc_otg_pcd_ep_t * ep,
     852                 :            :                              void *req_handle)
     853                 :            : {
     854                 :            :         int i;
     855                 :            :         dwc_ep_t *dwc_ep;
     856                 :            : 
     857                 :            :         dwc_ep = &ep->dwc_ep;
     858                 :            : 
     859                 :            :         DWC_SPINUNLOCK(ep->pcd->lock);
     860                 :            :         pcd->fops->isoc_complete(pcd, ep->priv, ep->iso_req_handle,
     861                 :            :                                  dwc_ep->proc_buf_num ^ 0x1);
     862                 :            :         DWC_SPINLOCK(ep->pcd->lock);
     863                 :            : 
     864                 :            :         for (i = 0; i < dwc_ep->pkt_cnt; ++i) {
     865                 :            :                 dwc_ep->pkt_info[i].status = 0;
     866                 :            :                 dwc_ep->pkt_info[i].offset = 0;
     867                 :            :                 dwc_ep->pkt_info[i].length = 0;
     868                 :            :         }
     869                 :            : }
     870                 :            : 
     871                 :            : int dwc_otg_pcd_get_iso_packet_count(dwc_otg_pcd_t * pcd, void *ep_handle,
     872                 :            :                                      void *iso_req_handle)
     873                 :            : {
     874                 :            :         dwc_otg_pcd_ep_t *ep;
     875                 :            :         dwc_ep_t *dwc_ep;
     876                 :            : 
     877                 :            :         ep = get_ep_from_handle(pcd, ep_handle);
     878                 :            :         if (!ep->desc || ep->dwc_ep.num == 0) {
     879                 :            :                 DWC_WARN("bad ep\n");
     880                 :            :                 return -DWC_E_INVALID;
     881                 :            :         }
     882                 :            :         dwc_ep = &ep->dwc_ep;
     883                 :            : 
     884                 :            :         return dwc_ep->pkt_cnt;
     885                 :            : }
     886                 :            : 
     887                 :            : void dwc_otg_pcd_get_iso_packet_params(dwc_otg_pcd_t * pcd, void *ep_handle,
     888                 :            :                                        void *iso_req_handle, int packet,
     889                 :            :                                        int *status, int *actual, int *offset)
     890                 :            : {
     891                 :            :         dwc_otg_pcd_ep_t *ep;
     892                 :            :         dwc_ep_t *dwc_ep;
     893                 :            : 
     894                 :            :         ep = get_ep_from_handle(pcd, ep_handle);
     895                 :            :         if (!ep)
     896                 :            :                 DWC_WARN("bad ep\n");
     897                 :            : 
     898                 :            :         dwc_ep = &ep->dwc_ep;
     899                 :            : 
     900                 :            :         *status = dwc_ep->pkt_info[packet].status;
     901                 :            :         *actual = dwc_ep->pkt_info[packet].length;
     902                 :            :         *offset = dwc_ep->pkt_info[packet].offset;
     903                 :            : }
     904                 :            : 
     905                 :            : #endif /* DWC_EN_ISOC */
     906                 :            : 
     907                 :            : static void dwc_otg_pcd_init_ep(dwc_otg_pcd_t * pcd, dwc_otg_pcd_ep_t * pcd_ep,
     908                 :            :                                 uint32_t is_in, uint32_t ep_num)
     909                 :            : {
     910                 :            :         /* Init EP structure */
     911                 :          3 :         pcd_ep->desc = 0;
     912                 :          3 :         pcd_ep->pcd = pcd;
     913                 :          3 :         pcd_ep->stopped = 1;
     914                 :          3 :         pcd_ep->queue_sof = 0;
     915                 :            : 
     916                 :            :         /* Init DWC ep structure */
     917                 :          3 :         pcd_ep->dwc_ep.is_in = is_in;
     918                 :          3 :         pcd_ep->dwc_ep.num = ep_num;
     919                 :          3 :         pcd_ep->dwc_ep.active = 0;
     920                 :          3 :         pcd_ep->dwc_ep.tx_fifo_num = 0;
     921                 :            :         /* Control until ep is actvated */
     922                 :          3 :         pcd_ep->dwc_ep.type = DWC_OTG_EP_TYPE_CONTROL;
     923                 :          3 :         pcd_ep->dwc_ep.maxpacket = MAX_PACKET_SIZE;
     924                 :          3 :         pcd_ep->dwc_ep.dma_addr = 0;
     925                 :          3 :         pcd_ep->dwc_ep.start_xfer_buff = 0;
     926                 :          3 :         pcd_ep->dwc_ep.xfer_buff = 0;
     927                 :          3 :         pcd_ep->dwc_ep.xfer_len = 0;
     928                 :          3 :         pcd_ep->dwc_ep.xfer_count = 0;
     929                 :          3 :         pcd_ep->dwc_ep.sent_zlp = 0;
     930                 :          3 :         pcd_ep->dwc_ep.total_len = 0;
     931                 :          3 :         pcd_ep->dwc_ep.desc_addr = 0;
     932                 :          3 :         pcd_ep->dwc_ep.dma_desc_addr = 0;
     933                 :          3 :         DWC_CIRCLEQ_INIT(&pcd_ep->queue);
     934                 :            : }
     935                 :            : 
     936                 :            : /**
     937                 :            :  * Initialize ep's
     938                 :            :  */
     939                 :          3 : static void dwc_otg_pcd_reinit(dwc_otg_pcd_t * pcd)
     940                 :            : {
     941                 :            :         int i;
     942                 :            :         uint32_t hwcfg1;
     943                 :            :         dwc_otg_pcd_ep_t *ep;
     944                 :            :         int in_ep_cntr, out_ep_cntr;
     945                 :          3 :         uint32_t num_in_eps = (GET_CORE_IF(pcd))->dev_if->num_in_eps;
     946                 :          3 :         uint32_t num_out_eps = (GET_CORE_IF(pcd))->dev_if->num_out_eps;
     947                 :            : 
     948                 :            :         /**
     949                 :            :          * Initialize the EP0 structure.
     950                 :            :          */
     951                 :            :         ep = &pcd->ep0;
     952                 :            :         dwc_otg_pcd_init_ep(pcd, ep, 0, 0);
     953                 :            : 
     954                 :            :         in_ep_cntr = 0;
     955                 :          3 :         hwcfg1 = (GET_CORE_IF(pcd))->hwcfg1.d32 >> 3;
     956                 :          3 :         for (i = 1; in_ep_cntr < num_in_eps; i++) {
     957                 :          2 :                 if ((hwcfg1 & 0x1) == 0) {
     958                 :            :                         dwc_otg_pcd_ep_t *ep = &pcd->in_ep[in_ep_cntr];
     959                 :          2 :                         in_ep_cntr++;
     960                 :            :                         /**
     961                 :            :                          * @todo NGS: Add direction to EP, based on contents
     962                 :            :                          * of HWCFG1.  Need a copy of HWCFG1 in pcd structure?
     963                 :            :                          * sprintf(";r
     964                 :            :                          */
     965                 :            :                         dwc_otg_pcd_init_ep(pcd, ep, 1 /* IN */ , i);
     966                 :            : 
     967                 :          2 :                         DWC_CIRCLEQ_INIT(&ep->queue);
     968                 :            :                 }
     969                 :          2 :                 hwcfg1 >>= 2;
     970                 :            :         }
     971                 :            : 
     972                 :            :         out_ep_cntr = 0;
     973                 :          3 :         hwcfg1 = (GET_CORE_IF(pcd))->hwcfg1.d32 >> 2;
     974                 :          3 :         for (i = 1; out_ep_cntr < num_out_eps; i++) {
     975                 :          2 :                 if ((hwcfg1 & 0x1) == 0) {
     976                 :            :                         dwc_otg_pcd_ep_t *ep = &pcd->out_ep[out_ep_cntr];
     977                 :          2 :                         out_ep_cntr++;
     978                 :            :                         /**
     979                 :            :                          * @todo NGS: Add direction to EP, based on contents
     980                 :            :                          * of HWCFG1.  Need a copy of HWCFG1 in pcd structure?
     981                 :            :                          * sprintf(";r
     982                 :            :                          */
     983                 :            :                         dwc_otg_pcd_init_ep(pcd, ep, 0 /* OUT */ , i);
     984                 :          2 :                         DWC_CIRCLEQ_INIT(&ep->queue);
     985                 :            :                 }
     986                 :          2 :                 hwcfg1 >>= 2;
     987                 :            :         }
     988                 :            : 
     989                 :          3 :         pcd->ep0state = EP0_DISCONNECT;
     990                 :          3 :         pcd->ep0.dwc_ep.maxpacket = MAX_EP0_SIZE;
     991                 :            :         pcd->ep0.dwc_ep.type = DWC_OTG_EP_TYPE_CONTROL;
     992                 :          3 : }
     993                 :            : 
     994                 :            : /**
     995                 :            :  * This function is called when the SRP timer expires. The SRP should
     996                 :            :  * complete within 6 seconds.
     997                 :            :  */
     998                 :          0 : static void srp_timeout(void *ptr)
     999                 :            : {
    1000                 :            :         gotgctl_data_t gotgctl;
    1001                 :            :         dwc_otg_core_if_t *core_if = (dwc_otg_core_if_t *) ptr;
    1002                 :          0 :         volatile uint32_t *addr = &core_if->core_global_regs->gotgctl;
    1003                 :            : 
    1004                 :          0 :         gotgctl.d32 = DWC_READ_REG32(addr);
    1005                 :            : 
    1006                 :          0 :         core_if->srp_timer_started = 0;
    1007                 :            : 
    1008                 :          0 :         if (core_if->adp_enable) {
    1009                 :          0 :                 if (gotgctl.b.bsesvld == 0) {
    1010                 :          0 :                         gpwrdn_data_t gpwrdn = {.d32 = 0 };
    1011                 :          0 :                         DWC_PRINTF("SRP Timeout BSESSVLD = 0\n");
    1012                 :            :                         /* Power off the core */
    1013                 :          0 :                         if (core_if->power_down == 2) {
    1014                 :          0 :                                 gpwrdn.b.pwrdnswtch = 1;
    1015                 :          0 :                                 DWC_MODIFY_REG32(&core_if->
    1016                 :            :                                                  core_global_regs->gpwrdn,
    1017                 :            :                                                  gpwrdn.d32, 0);
    1018                 :            :                         }
    1019                 :            : 
    1020                 :          0 :                         gpwrdn.d32 = 0;
    1021                 :          0 :                         gpwrdn.b.pmuintsel = 1;
    1022                 :          0 :                         gpwrdn.b.pmuactv = 1;
    1023                 :          0 :                         DWC_MODIFY_REG32(&core_if->core_global_regs->gpwrdn, 0,
    1024                 :            :                                          gpwrdn.d32);
    1025                 :          0 :                         dwc_otg_adp_probe_start(core_if);
    1026                 :            :                 } else {
    1027                 :          0 :                         DWC_PRINTF("SRP Timeout BSESSVLD = 1\n");
    1028                 :          0 :                         core_if->op_state = B_PERIPHERAL;
    1029                 :          0 :                         dwc_otg_core_init(core_if);
    1030                 :          0 :                         dwc_otg_enable_global_interrupts(core_if);
    1031                 :            :                         cil_pcd_start(core_if);
    1032                 :            :                 }
    1033                 :            :         }
    1034                 :            : 
    1035                 :          0 :         if ((core_if->core_params->phy_type == DWC_PHY_TYPE_PARAM_FS) &&
    1036                 :          0 :             (core_if->core_params->i2c_enable)) {
    1037                 :          0 :                 DWC_PRINTF("SRP Timeout\n");
    1038                 :            : 
    1039                 :          0 :                 if ((core_if->srp_success) && (gotgctl.b.bsesvld)) {
    1040                 :          0 :                         if (core_if->pcd_cb && core_if->pcd_cb->resume_wakeup) {
    1041                 :          0 :                                 core_if->pcd_cb->resume_wakeup(core_if->pcd_cb->p);
    1042                 :            :                         }
    1043                 :            : 
    1044                 :            :                         /* Clear Session Request */
    1045                 :          0 :                         gotgctl.d32 = 0;
    1046                 :          0 :                         gotgctl.b.sesreq = 1;
    1047                 :          0 :                         DWC_MODIFY_REG32(&core_if->core_global_regs->gotgctl,
    1048                 :            :                                          gotgctl.d32, 0);
    1049                 :            : 
    1050                 :          0 :                         core_if->srp_success = 0;
    1051                 :            :                 } else {
    1052                 :          0 :                         __DWC_ERROR("Device not connected/responding\n");
    1053                 :          0 :                         gotgctl.b.sesreq = 0;
    1054                 :          0 :                         DWC_WRITE_REG32(addr, gotgctl.d32);
    1055                 :            :                 }
    1056                 :          0 :         } else if (gotgctl.b.sesreq) {
    1057                 :          0 :                 DWC_PRINTF("SRP Timeout\n");
    1058                 :            : 
    1059                 :          0 :                 __DWC_ERROR("Device not connected/responding\n");
    1060                 :          0 :                 gotgctl.b.sesreq = 0;
    1061                 :          0 :                 DWC_WRITE_REG32(addr, gotgctl.d32);
    1062                 :            :         } else {
    1063                 :          0 :                 DWC_PRINTF(" SRP GOTGCTL=%0x\n", gotgctl.d32);
    1064                 :            :         }
    1065                 :          0 : }
    1066                 :            : 
    1067                 :            : /**
    1068                 :            :  * Tasklet
    1069                 :            :  *
    1070                 :            :  */
    1071                 :            : extern void start_next_request(dwc_otg_pcd_ep_t * ep);
    1072                 :            : 
    1073                 :          0 : static void start_xfer_tasklet_func(void *data)
    1074                 :            : {
    1075                 :            :         dwc_otg_pcd_t *pcd = (dwc_otg_pcd_t *) data;
    1076                 :          0 :         dwc_otg_core_if_t *core_if = GET_CORE_IF(pcd);
    1077                 :            : 
    1078                 :            :         int i;
    1079                 :            :         depctl_data_t diepctl;
    1080                 :            : 
    1081                 :            :         DWC_DEBUGPL(DBG_PCDV, "Start xfer tasklet\n");
    1082                 :            : 
    1083                 :          0 :         diepctl.d32 = DWC_READ_REG32(&core_if->dev_if->in_ep_regs[0]->diepctl);
    1084                 :            : 
    1085                 :          0 :         if (pcd->ep0.queue_sof) {
    1086                 :          0 :                 pcd->ep0.queue_sof = 0;
    1087                 :          0 :                 start_next_request(&pcd->ep0);
    1088                 :            :                 // break;
    1089                 :            :         }
    1090                 :            : 
    1091                 :          0 :         for (i = 0; i < core_if->dev_if->num_in_eps; i++) {
    1092                 :            :                 depctl_data_t diepctl;
    1093                 :            :                 diepctl.d32 =
    1094                 :          0 :                     DWC_READ_REG32(&core_if->dev_if->in_ep_regs[i]->diepctl);
    1095                 :            : 
    1096                 :          0 :                 if (pcd->in_ep[i].queue_sof) {
    1097                 :          0 :                         pcd->in_ep[i].queue_sof = 0;
    1098                 :          0 :                         start_next_request(&pcd->in_ep[i]);
    1099                 :            :                         // break;
    1100                 :            :                 }
    1101                 :            :         }
    1102                 :            : 
    1103                 :          0 :         return;
    1104                 :            : }
    1105                 :            : 
    1106                 :            : /**
    1107                 :            :  * This function initialized the PCD portion of the driver.
    1108                 :            :  *
    1109                 :            :  */
    1110                 :          3 : dwc_otg_pcd_t *dwc_otg_pcd_init(dwc_otg_device_t *otg_dev)
    1111                 :            : {
    1112                 :          3 :         struct device *dev = &otg_dev->os_dep.platformdev->dev;
    1113                 :          3 :         dwc_otg_core_if_t *core_if = otg_dev->core_if;
    1114                 :            :         dwc_otg_pcd_t *pcd = NULL;
    1115                 :            :         dwc_otg_dev_if_t *dev_if;
    1116                 :            :         int i;
    1117                 :            : 
    1118                 :            :         /*
    1119                 :            :          * Allocate PCD structure
    1120                 :            :          */
    1121                 :          3 :         pcd = DWC_ALLOC(sizeof(dwc_otg_pcd_t));
    1122                 :            : 
    1123                 :          3 :         if (pcd == NULL) {
    1124                 :            :                 return NULL;
    1125                 :            :         }
    1126                 :            : 
    1127                 :            : #if (defined(DWC_LINUX) && defined(CONFIG_DEBUG_SPINLOCK))
    1128                 :            :         DWC_SPINLOCK_ALLOC_LINUX_DEBUG(pcd->lock);
    1129                 :            : #else
    1130                 :          3 :         pcd->lock = DWC_SPINLOCK_ALLOC();
    1131                 :            : #endif
    1132                 :            :         DWC_DEBUGPL(DBG_HCDV, "Init of PCD %p given core_if %p\n",
    1133                 :            :                     pcd, core_if);//GRAYG
    1134                 :          3 :         if (!pcd->lock) {
    1135                 :          0 :                 DWC_ERROR("Could not allocate lock for pcd");
    1136                 :          0 :                 DWC_FREE(pcd);
    1137                 :          0 :                 return NULL;
    1138                 :            :         }
    1139                 :            :         /* Set core_if's lock pointer to hcd->lock */
    1140                 :          3 :         core_if->lock = pcd->lock;
    1141                 :          3 :         pcd->core_if = core_if;
    1142                 :            : 
    1143                 :          3 :         dev_if = core_if->dev_if;
    1144                 :          3 :         dev_if->isoc_ep = NULL;
    1145                 :            : 
    1146                 :          3 :         if (core_if->hwcfg4.b.ded_fifo_en) {
    1147                 :          2 :                 DWC_PRINTF("Dedicated Tx FIFOs mode\n");
    1148                 :            :         } else {
    1149                 :          1 :                 DWC_PRINTF("Shared Tx FIFO mode\n");
    1150                 :            :         }
    1151                 :            : 
    1152                 :            :         /*
    1153                 :            :          * Initialized the Core for Device mode here if there is nod ADP support.
    1154                 :            :          * Otherwise it will be done later in dwc_otg_adp_start routine.
    1155                 :            :          */
    1156                 :          3 :         if (dwc_otg_is_device_mode(core_if) /*&& !core_if->adp_enable*/) {
    1157                 :          0 :                 dwc_otg_core_dev_init(core_if);
    1158                 :            :         }
    1159                 :            : 
    1160                 :            :         /*
    1161                 :            :          * Register the PCD Callbacks.
    1162                 :            :          */
    1163                 :          3 :         dwc_otg_cil_register_pcd_callbacks(core_if, &pcd_callbacks, pcd);
    1164                 :            : 
    1165                 :            :         /*
    1166                 :            :          * Initialize the DMA buffer for SETUP packets
    1167                 :            :          */
    1168                 :          3 :         if (GET_CORE_IF(pcd)->dma_enable) {
    1169                 :          3 :                 pcd->setup_pkt =
    1170                 :          3 :                     DWC_DMA_ALLOC(dev, sizeof(*pcd->setup_pkt) * 5,
    1171                 :            :                                   &pcd->setup_pkt_dma_handle);
    1172                 :          3 :                 if (pcd->setup_pkt == NULL) {
    1173                 :          0 :                         DWC_FREE(pcd);
    1174                 :          0 :                         return NULL;
    1175                 :            :                 }
    1176                 :            : 
    1177                 :          3 :                 pcd->status_buf =
    1178                 :          3 :                     DWC_DMA_ALLOC(dev, sizeof(uint16_t),
    1179                 :            :                                   &pcd->status_buf_dma_handle);
    1180                 :          3 :                 if (pcd->status_buf == NULL) {
    1181                 :          0 :                         DWC_DMA_FREE(dev, sizeof(*pcd->setup_pkt) * 5,
    1182                 :            :                                      pcd->setup_pkt, pcd->setup_pkt_dma_handle);
    1183                 :          0 :                         DWC_FREE(pcd);
    1184                 :          0 :                         return NULL;
    1185                 :            :                 }
    1186                 :            : 
    1187                 :          3 :                 if (GET_CORE_IF(pcd)->dma_desc_enable) {
    1188                 :          0 :                         dev_if->setup_desc_addr[0] =
    1189                 :          0 :                             dwc_otg_ep_alloc_desc_chain(dev,
    1190                 :            :                                 &dev_if->dma_setup_desc_addr[0], 1);
    1191                 :          0 :                         dev_if->setup_desc_addr[1] =
    1192                 :          0 :                             dwc_otg_ep_alloc_desc_chain(dev,
    1193                 :            :                                 &dev_if->dma_setup_desc_addr[1], 1);
    1194                 :          0 :                         dev_if->in_desc_addr =
    1195                 :          0 :                             dwc_otg_ep_alloc_desc_chain(dev,
    1196                 :            :                                 &dev_if->dma_in_desc_addr, 1);
    1197                 :          0 :                         dev_if->out_desc_addr =
    1198                 :          0 :                             dwc_otg_ep_alloc_desc_chain(dev,
    1199                 :            :                                 &dev_if->dma_out_desc_addr, 1);
    1200                 :          0 :                         pcd->data_terminated = 0;
    1201                 :            : 
    1202                 :          0 :                         if (dev_if->setup_desc_addr[0] == 0
    1203                 :          0 :                             || dev_if->setup_desc_addr[1] == 0
    1204                 :          0 :                             || dev_if->in_desc_addr == 0
    1205                 :          0 :                             || dev_if->out_desc_addr == 0) {
    1206                 :            : 
    1207                 :          0 :                                 if (dev_if->out_desc_addr)
    1208                 :          0 :                                         dwc_otg_ep_free_desc_chain(dev,
    1209                 :            :                                              dev_if->out_desc_addr,
    1210                 :            :                                              dev_if->dma_out_desc_addr, 1);
    1211                 :          0 :                                 if (dev_if->in_desc_addr)
    1212                 :          0 :                                         dwc_otg_ep_free_desc_chain(dev,
    1213                 :            :                                              dev_if->in_desc_addr,
    1214                 :            :                                              dev_if->dma_in_desc_addr, 1);
    1215                 :          0 :                                 if (dev_if->setup_desc_addr[1])
    1216                 :          0 :                                         dwc_otg_ep_free_desc_chain(dev,
    1217                 :            :                                              dev_if->setup_desc_addr[1],
    1218                 :            :                                              dev_if->dma_setup_desc_addr[1], 1);
    1219                 :          0 :                                 if (dev_if->setup_desc_addr[0])
    1220                 :          0 :                                         dwc_otg_ep_free_desc_chain(dev,
    1221                 :            :                                              dev_if->setup_desc_addr[0],
    1222                 :            :                                              dev_if->dma_setup_desc_addr[0], 1);
    1223                 :            : 
    1224                 :          0 :                                 DWC_DMA_FREE(dev, sizeof(*pcd->setup_pkt) * 5,
    1225                 :            :                                              pcd->setup_pkt,
    1226                 :            :                                              pcd->setup_pkt_dma_handle);
    1227                 :          0 :                                 DWC_DMA_FREE(dev, sizeof(*pcd->status_buf),
    1228                 :            :                                              pcd->status_buf,
    1229                 :            :                                              pcd->status_buf_dma_handle);
    1230                 :            : 
    1231                 :          0 :                                 DWC_FREE(pcd);
    1232                 :            : 
    1233                 :          0 :                                 return NULL;
    1234                 :            :                         }
    1235                 :            :                 }
    1236                 :            :         } else {
    1237                 :          0 :                 pcd->setup_pkt = DWC_ALLOC(sizeof(*pcd->setup_pkt) * 5);
    1238                 :          0 :                 if (pcd->setup_pkt == NULL) {
    1239                 :          0 :                         DWC_FREE(pcd);
    1240                 :          0 :                         return NULL;
    1241                 :            :                 }
    1242                 :            : 
    1243                 :          0 :                 pcd->status_buf = DWC_ALLOC(sizeof(uint16_t));
    1244                 :          0 :                 if (pcd->status_buf == NULL) {
    1245                 :          0 :                         DWC_FREE(pcd->setup_pkt);
    1246                 :          0 :                         DWC_FREE(pcd);
    1247                 :          0 :                         return NULL;
    1248                 :            :                 }
    1249                 :            :         }
    1250                 :            : 
    1251                 :          3 :         dwc_otg_pcd_reinit(pcd);
    1252                 :            : 
    1253                 :            :         /* Allocate the cfi object for the PCD */
    1254                 :            : #ifdef DWC_UTE_CFI
    1255                 :            :         pcd->cfi = DWC_ALLOC(sizeof(cfiobject_t));
    1256                 :            :         if (NULL == pcd->cfi)
    1257                 :            :                 goto fail;
    1258                 :            :         if (init_cfi(pcd->cfi)) {
    1259                 :            :                 CFI_INFO("%s: Failed to init the CFI object\n", __func__);
    1260                 :            :                 goto fail;
    1261                 :            :         }
    1262                 :            : #endif
    1263                 :            : 
    1264                 :            :         /* Initialize tasklets */
    1265                 :          3 :         pcd->start_xfer_tasklet = DWC_TASK_ALLOC("xfer_tasklet",
    1266                 :            :                                                  start_xfer_tasklet_func, pcd);
    1267                 :          3 :         pcd->test_mode_tasklet = DWC_TASK_ALLOC("test_mode_tasklet",
    1268                 :            :                                                 do_test_mode, pcd);
    1269                 :            : 
    1270                 :            :         /* Initialize SRP timer */
    1271                 :          3 :         core_if->srp_timer = DWC_TIMER_ALLOC("SRP TIMER", srp_timeout, core_if);
    1272                 :            : 
    1273                 :          3 :         if (core_if->core_params->dev_out_nak) {
    1274                 :            :                 /**
    1275                 :            :                 * Initialize xfer timeout timer. Implemented for
    1276                 :            :                 * 2.93a feature "Device DDMA OUT NAK Enhancement"
    1277                 :            :                 */
    1278                 :          0 :                 for(i = 0; i < MAX_EPS_CHANNELS; i++) {
    1279                 :          0 :                         pcd->core_if->ep_xfer_timer[i] =
    1280                 :          0 :                                 DWC_TIMER_ALLOC("ep timer", ep_xfer_timeout,
    1281                 :          0 :                                 &pcd->core_if->ep_xfer_info[i]);
    1282                 :            :                 }
    1283                 :            :         }
    1284                 :            : 
    1285                 :          3 :         return pcd;
    1286                 :            : #ifdef DWC_UTE_CFI
    1287                 :            : fail:
    1288                 :            : #endif
    1289                 :            :         if (pcd->setup_pkt)
    1290                 :            :                 DWC_FREE(pcd->setup_pkt);
    1291                 :            :         if (pcd->status_buf)
    1292                 :            :                 DWC_FREE(pcd->status_buf);
    1293                 :            : #ifdef DWC_UTE_CFI
    1294                 :            :         if (pcd->cfi)
    1295                 :            :                 DWC_FREE(pcd->cfi);
    1296                 :            : #endif
    1297                 :            :         if (pcd)
    1298                 :            :                 DWC_FREE(pcd);
    1299                 :            :         return NULL;
    1300                 :            : 
    1301                 :            : }
    1302                 :            : 
    1303                 :            : /**
    1304                 :            :  * Remove PCD specific data
    1305                 :            :  */
    1306                 :          0 : void dwc_otg_pcd_remove(dwc_otg_pcd_t * pcd)
    1307                 :            : {
    1308                 :          0 :         dwc_otg_dev_if_t *dev_if = GET_CORE_IF(pcd)->dev_if;
    1309                 :            :         struct device *dev = dwc_otg_pcd_to_dev(pcd);
    1310                 :            :         int i;
    1311                 :            : 
    1312                 :          0 :         if (pcd->core_if->core_params->dev_out_nak) {
    1313                 :          0 :                 for (i = 0; i < MAX_EPS_CHANNELS; i++) {
    1314                 :          0 :                         DWC_TIMER_CANCEL(pcd->core_if->ep_xfer_timer[i]);
    1315                 :          0 :                         pcd->core_if->ep_xfer_info[i].state = 0;
    1316                 :            :                 }
    1317                 :            :         }
    1318                 :            : 
    1319                 :          0 :         if (GET_CORE_IF(pcd)->dma_enable) {
    1320                 :          0 :                 DWC_DMA_FREE(dev, sizeof(*pcd->setup_pkt) * 5, pcd->setup_pkt,
    1321                 :            :                              pcd->setup_pkt_dma_handle);
    1322                 :          0 :                 DWC_DMA_FREE(dev, sizeof(uint16_t), pcd->status_buf,
    1323                 :            :                              pcd->status_buf_dma_handle);
    1324                 :          0 :                 if (GET_CORE_IF(pcd)->dma_desc_enable) {
    1325                 :          0 :                         dwc_otg_ep_free_desc_chain(dev,
    1326                 :            :                                                    dev_if->setup_desc_addr[0],
    1327                 :            :                                                    dev_if->dma_setup_desc_addr
    1328                 :            :                                                    [0], 1);
    1329                 :          0 :                         dwc_otg_ep_free_desc_chain(dev,
    1330                 :            :                                                    dev_if->setup_desc_addr[1],
    1331                 :            :                                                    dev_if->dma_setup_desc_addr
    1332                 :            :                                                    [1], 1);
    1333                 :          0 :                         dwc_otg_ep_free_desc_chain(dev,
    1334                 :            :                                                    dev_if->in_desc_addr,
    1335                 :            :                                                    dev_if->dma_in_desc_addr, 1);
    1336                 :          0 :                         dwc_otg_ep_free_desc_chain(dev,
    1337                 :            :                                                    dev_if->out_desc_addr,
    1338                 :            :                                                    dev_if->dma_out_desc_addr,
    1339                 :            :                                                    1);
    1340                 :            :                 }
    1341                 :            :         } else {
    1342                 :          0 :                 DWC_FREE(pcd->setup_pkt);
    1343                 :          0 :                 DWC_FREE(pcd->status_buf);
    1344                 :            :         }
    1345                 :          0 :         DWC_SPINLOCK_FREE(pcd->lock);
    1346                 :            :         /* Set core_if's lock pointer to NULL */
    1347                 :          0 :         pcd->core_if->lock = NULL;
    1348                 :            : 
    1349                 :          0 :         DWC_TASK_FREE(pcd->start_xfer_tasklet);
    1350                 :          0 :         DWC_TASK_FREE(pcd->test_mode_tasklet);
    1351                 :          0 :         if (pcd->core_if->core_params->dev_out_nak) {
    1352                 :          0 :                 for (i = 0; i < MAX_EPS_CHANNELS; i++) {
    1353                 :          0 :                         if (pcd->core_if->ep_xfer_timer[i]) {
    1354                 :          0 :                                         DWC_TIMER_FREE(pcd->core_if->ep_xfer_timer[i]);
    1355                 :            :                         }
    1356                 :            :                 }
    1357                 :            :         }
    1358                 :            : 
    1359                 :            : /* Release the CFI object's dynamic memory */
    1360                 :            : #ifdef DWC_UTE_CFI
    1361                 :            :         if (pcd->cfi->ops.release) {
    1362                 :            :                 pcd->cfi->ops.release(pcd->cfi);
    1363                 :            :         }
    1364                 :            : #endif
    1365                 :            : 
    1366                 :          0 :         DWC_FREE(pcd);
    1367                 :          0 : }
    1368                 :            : 
    1369                 :            : /**
    1370                 :            :  * Returns whether registered pcd is dual speed or not
    1371                 :            :  */
    1372                 :          3 : uint32_t dwc_otg_pcd_is_dualspeed(dwc_otg_pcd_t * pcd)
    1373                 :            : {
    1374                 :          3 :         dwc_otg_core_if_t *core_if = GET_CORE_IF(pcd);
    1375                 :            : 
    1376                 :          3 :         if ((core_if->core_params->speed == DWC_SPEED_PARAM_FULL) ||
    1377                 :          3 :             ((core_if->hwcfg2.b.hs_phy_type == 2) &&
    1378                 :          0 :              (core_if->hwcfg2.b.fs_phy_type == 1) &&
    1379                 :          0 :              (core_if->core_params->ulpi_fs_ls))) {
    1380                 :            :                 return 0;
    1381                 :            :         }
    1382                 :            : 
    1383                 :          3 :         return 1;
    1384                 :            : }
    1385                 :            : 
    1386                 :            : /**
    1387                 :            :  * Returns whether registered pcd is OTG capable or not
    1388                 :            :  */
    1389                 :          3 : uint32_t dwc_otg_pcd_is_otg(dwc_otg_pcd_t * pcd)
    1390                 :            : {
    1391                 :          3 :         dwc_otg_core_if_t *core_if = GET_CORE_IF(pcd);
    1392                 :            :         gusbcfg_data_t usbcfg = {.d32 = 0 };
    1393                 :            : 
    1394                 :          3 :         usbcfg.d32 = DWC_READ_REG32(&core_if->core_global_regs->gusbcfg);
    1395                 :          3 :         if (!usbcfg.b.srpcap || !usbcfg.b.hnpcap) {
    1396                 :            :                 return 0;
    1397                 :            :         }
    1398                 :            : 
    1399                 :          2 :         return 1;
    1400                 :            : }
    1401                 :            : 
    1402                 :            : /**
    1403                 :            :  * This function assigns periodic Tx FIFO to an periodic EP
    1404                 :            :  * in shared Tx FIFO mode
    1405                 :            :  */
    1406                 :            : static uint32_t assign_tx_fifo(dwc_otg_core_if_t * core_if)
    1407                 :            : {
    1408                 :            :         uint32_t TxMsk = 1;
    1409                 :            :         int i;
    1410                 :            : 
    1411                 :          0 :         for (i = 0; i < core_if->hwcfg4.b.num_in_eps; ++i) {
    1412                 :          0 :                 if ((TxMsk & core_if->tx_msk) == 0) {
    1413                 :          0 :                         core_if->tx_msk |= TxMsk;
    1414                 :          0 :                         return i + 1;
    1415                 :            :                 }
    1416                 :          0 :                 TxMsk <<= 1;
    1417                 :            :         }
    1418                 :            :         return 0;
    1419                 :            : }
    1420                 :            : 
    1421                 :            : /**
    1422                 :            :  * This function assigns periodic Tx FIFO to an periodic EP
    1423                 :            :  * in shared Tx FIFO mode
    1424                 :            :  */
    1425                 :            : static uint32_t assign_perio_tx_fifo(dwc_otg_core_if_t * core_if)
    1426                 :            : {
    1427                 :            :         uint32_t PerTxMsk = 1;
    1428                 :            :         int i;
    1429                 :          0 :         for (i = 0; i < core_if->hwcfg4.b.num_dev_perio_in_ep; ++i) {
    1430                 :          0 :                 if ((PerTxMsk & core_if->p_tx_msk) == 0) {
    1431                 :          0 :                         core_if->p_tx_msk |= PerTxMsk;
    1432                 :          0 :                         return i + 1;
    1433                 :            :                 }
    1434                 :          0 :                 PerTxMsk <<= 1;
    1435                 :            :         }
    1436                 :            :         return 0;
    1437                 :            : }
    1438                 :            : 
    1439                 :            : /**
    1440                 :            :  * This function releases periodic Tx FIFO
    1441                 :            :  * in shared Tx FIFO mode
    1442                 :            :  */
    1443                 :            : static void release_perio_tx_fifo(dwc_otg_core_if_t * core_if,
    1444                 :            :                                   uint32_t fifo_num)
    1445                 :            : {
    1446                 :          0 :         core_if->p_tx_msk =
    1447                 :          0 :             (core_if->p_tx_msk & (1 << (fifo_num - 1))) ^ core_if->p_tx_msk;
    1448                 :            : }
    1449                 :            : 
    1450                 :            : /**
    1451                 :            :  * This function releases periodic Tx FIFO
    1452                 :            :  * in shared Tx FIFO mode
    1453                 :            :  */
    1454                 :            : static void release_tx_fifo(dwc_otg_core_if_t * core_if, uint32_t fifo_num)
    1455                 :            : {
    1456                 :          0 :         core_if->tx_msk =
    1457                 :          0 :             (core_if->tx_msk & (1 << (fifo_num - 1))) ^ core_if->tx_msk;
    1458                 :            : }
    1459                 :            : 
    1460                 :            : /**
    1461                 :            :  * This function is being called from gadget
    1462                 :            :  * to enable PCD endpoint.
    1463                 :            :  */
    1464                 :          3 : int dwc_otg_pcd_ep_enable(dwc_otg_pcd_t * pcd,
    1465                 :            :                           const uint8_t * ep_desc, void *usb_ep)
    1466                 :            : {
    1467                 :            :         int num, dir;
    1468                 :            :         dwc_otg_pcd_ep_t *ep = NULL;
    1469                 :            :         const usb_endpoint_descriptor_t *desc;
    1470                 :            :         dwc_irqflags_t flags;
    1471                 :            :         fifosize_data_t dptxfsiz = {.d32 = 0 };
    1472                 :            :         gdfifocfg_data_t gdfifocfg = {.d32 = 0 };
    1473                 :            :         gdfifocfg_data_t gdfifocfgbase = {.d32 = 0 };
    1474                 :            :         int retval = 0;
    1475                 :            :         int i, epcount;
    1476                 :            :         struct device *dev = dwc_otg_pcd_to_dev(pcd);
    1477                 :            : 
    1478                 :            :         desc = (const usb_endpoint_descriptor_t *)ep_desc;
    1479                 :            : 
    1480                 :          3 :         if (!desc) {
    1481                 :          3 :                 pcd->ep0.priv = usb_ep;
    1482                 :            :                 ep = &pcd->ep0;
    1483                 :            :                 retval = -DWC_E_INVALID;
    1484                 :          3 :                 goto out;
    1485                 :            :         }
    1486                 :            : 
    1487                 :          0 :         num = UE_GET_ADDR(desc->bEndpointAddress);
    1488                 :          0 :         dir = UE_GET_DIR(desc->bEndpointAddress);
    1489                 :            : 
    1490                 :          0 :         if (!desc->wMaxPacketSize) {
    1491                 :          0 :                 DWC_WARN("bad maxpacketsize\n");
    1492                 :            :                 retval = -DWC_E_INVALID;
    1493                 :          0 :                 goto out;
    1494                 :            :         }
    1495                 :            : 
    1496                 :          0 :         if (dir == UE_DIR_IN) {
    1497                 :          0 :                 epcount = pcd->core_if->dev_if->num_in_eps;
    1498                 :          0 :                 for (i = 0; i < epcount; i++) {
    1499                 :          0 :                         if (num == pcd->in_ep[i].dwc_ep.num) {
    1500                 :          0 :                                 ep = &pcd->in_ep[i];
    1501                 :          0 :                                 break;
    1502                 :            :                         }
    1503                 :            :                 }
    1504                 :            :         } else {
    1505                 :          0 :                 epcount = pcd->core_if->dev_if->num_out_eps;
    1506                 :          0 :                 for (i = 0; i < epcount; i++) {
    1507                 :          0 :                         if (num == pcd->out_ep[i].dwc_ep.num) {
    1508                 :          0 :                                 ep = &pcd->out_ep[i];
    1509                 :          0 :                                 break;
    1510                 :            :                         }
    1511                 :            :                 }
    1512                 :            :         }
    1513                 :            : 
    1514                 :          0 :         if (!ep) {
    1515                 :          0 :                 DWC_WARN("bad address\n");
    1516                 :            :                 retval = -DWC_E_INVALID;
    1517                 :          0 :                 goto out;
    1518                 :            :         }
    1519                 :            : 
    1520                 :          0 :         DWC_SPINLOCK_IRQSAVE(pcd->lock, &flags);
    1521                 :            : 
    1522                 :          0 :         ep->desc = desc;
    1523                 :          0 :         ep->priv = usb_ep;
    1524                 :            : 
    1525                 :            :         /*
    1526                 :            :          * Activate the EP
    1527                 :            :          */
    1528                 :          0 :         ep->stopped = 0;
    1529                 :            : 
    1530                 :          0 :         ep->dwc_ep.is_in = (dir == UE_DIR_IN);
    1531                 :          0 :         ep->dwc_ep.maxpacket = UGETW(desc->wMaxPacketSize);
    1532                 :            : 
    1533                 :          0 :         ep->dwc_ep.type = desc->bmAttributes & UE_XFERTYPE;
    1534                 :            : 
    1535                 :          0 :         if (ep->dwc_ep.is_in) {
    1536                 :          0 :                 if (!GET_CORE_IF(pcd)->en_multiple_tx_fifo) {
    1537                 :          0 :                         ep->dwc_ep.tx_fifo_num = 0;
    1538                 :            : 
    1539                 :          0 :                         if (ep->dwc_ep.type == UE_ISOCHRONOUS) {
    1540                 :            :                                 /*
    1541                 :            :                                  * if ISOC EP then assign a Periodic Tx FIFO.
    1542                 :            :                                  */
    1543                 :          0 :                                 ep->dwc_ep.tx_fifo_num =
    1544                 :          0 :                                     assign_perio_tx_fifo(GET_CORE_IF(pcd));
    1545                 :            :                         }
    1546                 :            :                 } else {
    1547                 :            :                         /*
    1548                 :            :                          * if Dedicated FIFOs mode is on then assign a Tx FIFO.
    1549                 :            :                          */
    1550                 :          0 :                         ep->dwc_ep.tx_fifo_num =
    1551                 :            :                             assign_tx_fifo(GET_CORE_IF(pcd));
    1552                 :            :                 }
    1553                 :            : 
    1554                 :            :                 /* Calculating EP info controller base address */
    1555                 :          0 :                 if (ep->dwc_ep.tx_fifo_num
    1556                 :          0 :                     && GET_CORE_IF(pcd)->en_multiple_tx_fifo) {
    1557                 :          0 :                         gdfifocfg.d32 =
    1558                 :          0 :                             DWC_READ_REG32(&GET_CORE_IF(pcd)->
    1559                 :            :                                            core_global_regs->gdfifocfg);
    1560                 :          0 :                         gdfifocfgbase.d32 = gdfifocfg.d32 >> 16;
    1561                 :            :                         dptxfsiz.d32 =
    1562                 :          0 :                             (DWC_READ_REG32
    1563                 :          0 :                              (&GET_CORE_IF(pcd)->core_global_regs->
    1564                 :          0 :                               dtxfsiz[ep->dwc_ep.tx_fifo_num - 1]) >> 16);
    1565                 :          0 :                         gdfifocfg.b.epinfobase =
    1566                 :            :                             gdfifocfgbase.d32 + dptxfsiz.d32;
    1567                 :          0 :                         if (GET_CORE_IF(pcd)->snpsid <= OTG_CORE_REV_2_94a) {
    1568                 :          0 :                                 DWC_WRITE_REG32(&GET_CORE_IF(pcd)->
    1569                 :            :                                                 core_global_regs->gdfifocfg,
    1570                 :            :                                                 gdfifocfg.d32);
    1571                 :            :                         }
    1572                 :            :                 }
    1573                 :            :         }
    1574                 :            :         /* Set initial data PID. */
    1575                 :          0 :         if (ep->dwc_ep.type == UE_BULK) {
    1576                 :          0 :                 ep->dwc_ep.data_pid_start = 0;
    1577                 :            :         }
    1578                 :            : 
    1579                 :            :         /* Alloc DMA Descriptors */
    1580                 :          0 :         if (GET_CORE_IF(pcd)->dma_desc_enable) {
    1581                 :            : #ifndef DWC_UTE_PER_IO
    1582                 :          0 :                 if (ep->dwc_ep.type != UE_ISOCHRONOUS) {
    1583                 :            : #endif
    1584                 :          0 :                         ep->dwc_ep.desc_addr =
    1585                 :          0 :                             dwc_otg_ep_alloc_desc_chain(dev,
    1586                 :            :                                                 &ep->dwc_ep.dma_desc_addr,
    1587                 :            :                                                 MAX_DMA_DESC_CNT);
    1588                 :          0 :                         if (!ep->dwc_ep.desc_addr) {
    1589                 :          0 :                                 DWC_WARN("%s, can't allocate DMA descriptor\n",
    1590                 :            :                                          __func__);
    1591                 :            :                                 retval = -DWC_E_SHUTDOWN;
    1592                 :          0 :                                 DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    1593                 :          0 :                                 goto out;
    1594                 :            :                         }
    1595                 :            : #ifndef DWC_UTE_PER_IO
    1596                 :            :                 }
    1597                 :            : #endif
    1598                 :            :         }
    1599                 :            : 
    1600                 :            :         DWC_DEBUGPL(DBG_PCD, "Activate %s: type=%d, mps=%d desc=%p\n",
    1601                 :            :                     (ep->dwc_ep.is_in ? "IN" : "OUT"),
    1602                 :            :                     ep->dwc_ep.type, ep->dwc_ep.maxpacket, ep->desc);
    1603                 :            : #ifdef DWC_UTE_PER_IO
    1604                 :            :         ep->dwc_ep.xiso_bInterval = 1 << (ep->desc->bInterval - 1);
    1605                 :            : #endif
    1606                 :          0 :         if (ep->dwc_ep.type == DWC_OTG_EP_TYPE_ISOC) {
    1607                 :          0 :                 ep->dwc_ep.bInterval = 1 << (ep->desc->bInterval - 1);
    1608                 :          0 :                 ep->dwc_ep.frame_num = 0xFFFFFFFF;
    1609                 :            :         }
    1610                 :            : 
    1611                 :          0 :         dwc_otg_ep_activate(GET_CORE_IF(pcd), &ep->dwc_ep);
    1612                 :            : 
    1613                 :            : #ifdef DWC_UTE_CFI
    1614                 :            :         if (pcd->cfi->ops.ep_enable) {
    1615                 :            :                 pcd->cfi->ops.ep_enable(pcd->cfi, pcd, ep);
    1616                 :            :         }
    1617                 :            : #endif
    1618                 :            : 
    1619                 :          0 :         DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    1620                 :            : 
    1621                 :            : out:
    1622                 :          3 :         return retval;
    1623                 :            : }
    1624                 :            : 
    1625                 :            : /**
    1626                 :            :  * This function is being called from gadget
    1627                 :            :  * to disable PCD endpoint.
    1628                 :            :  */
    1629                 :          0 : int dwc_otg_pcd_ep_disable(dwc_otg_pcd_t * pcd, void *ep_handle)
    1630                 :            : {
    1631                 :            :         dwc_otg_pcd_ep_t *ep;
    1632                 :            :         dwc_irqflags_t flags;
    1633                 :            :         dwc_otg_dev_dma_desc_t *desc_addr;
    1634                 :            :         dwc_dma_t dma_desc_addr;
    1635                 :            :         gdfifocfg_data_t gdfifocfgbase = {.d32 = 0 };
    1636                 :            :         gdfifocfg_data_t gdfifocfg = {.d32 = 0 };
    1637                 :            :         fifosize_data_t dptxfsiz = {.d32 = 0 };
    1638                 :            :         struct device *dev = dwc_otg_pcd_to_dev(pcd);
    1639                 :            : 
    1640                 :            :         ep = get_ep_from_handle(pcd, ep_handle);
    1641                 :            : 
    1642                 :          0 :         if (!ep || !ep->desc) {
    1643                 :            :                 DWC_DEBUGPL(DBG_PCD, "bad ep address\n");
    1644                 :            :                 return -DWC_E_INVALID;
    1645                 :            :         }
    1646                 :            : 
    1647                 :          0 :         DWC_SPINLOCK_IRQSAVE(pcd->lock, &flags);
    1648                 :            : 
    1649                 :            :         dwc_otg_request_nuke(ep);
    1650                 :            : 
    1651                 :          0 :         dwc_otg_ep_deactivate(GET_CORE_IF(pcd), &ep->dwc_ep);
    1652                 :          0 :         if (pcd->core_if->core_params->dev_out_nak) {
    1653                 :          0 :                 DWC_TIMER_CANCEL(pcd->core_if->ep_xfer_timer[ep->dwc_ep.num]);
    1654                 :          0 :                 pcd->core_if->ep_xfer_info[ep->dwc_ep.num].state = 0;
    1655                 :            :         }
    1656                 :          0 :         ep->desc = NULL;
    1657                 :          0 :         ep->stopped = 1;
    1658                 :            : 
    1659                 :          0 :         gdfifocfg.d32 =
    1660                 :          0 :             DWC_READ_REG32(&GET_CORE_IF(pcd)->core_global_regs->gdfifocfg);
    1661                 :          0 :         gdfifocfgbase.d32 = gdfifocfg.d32 >> 16;
    1662                 :            : 
    1663                 :          0 :         if (ep->dwc_ep.is_in) {
    1664                 :          0 :                 if (GET_CORE_IF(pcd)->en_multiple_tx_fifo) {
    1665                 :            :                         /* Flush the Tx FIFO */
    1666                 :          0 :                         dwc_otg_flush_tx_fifo(GET_CORE_IF(pcd),
    1667                 :          0 :                                               ep->dwc_ep.tx_fifo_num);
    1668                 :            :                 }
    1669                 :          0 :                 release_perio_tx_fifo(GET_CORE_IF(pcd), ep->dwc_ep.tx_fifo_num);
    1670                 :          0 :                 release_tx_fifo(GET_CORE_IF(pcd), ep->dwc_ep.tx_fifo_num);
    1671                 :          0 :                 if (GET_CORE_IF(pcd)->en_multiple_tx_fifo) {
    1672                 :            :                         /* Decreasing EPinfo Base Addr */
    1673                 :            :                         dptxfsiz.d32 =
    1674                 :          0 :                             (DWC_READ_REG32
    1675                 :          0 :                              (&GET_CORE_IF(pcd)->
    1676                 :          0 :                                 core_global_regs->dtxfsiz[ep->dwc_ep.tx_fifo_num-1]) >> 16);
    1677                 :          0 :                         gdfifocfg.b.epinfobase = gdfifocfgbase.d32 - dptxfsiz.d32;
    1678                 :          0 :                         if (GET_CORE_IF(pcd)->snpsid <= OTG_CORE_REV_2_94a) {
    1679                 :          0 :                                 DWC_WRITE_REG32(&GET_CORE_IF(pcd)->core_global_regs->gdfifocfg,
    1680                 :            :                                         gdfifocfg.d32);
    1681                 :            :                         }
    1682                 :            :                 }
    1683                 :            :         }
    1684                 :            : 
    1685                 :            :         /* Free DMA Descriptors */
    1686                 :          0 :         if (GET_CORE_IF(pcd)->dma_desc_enable) {
    1687                 :          0 :                 if (ep->dwc_ep.type != UE_ISOCHRONOUS) {
    1688                 :          0 :                         desc_addr = ep->dwc_ep.desc_addr;
    1689                 :          0 :                         dma_desc_addr = ep->dwc_ep.dma_desc_addr;
    1690                 :            : 
    1691                 :            :                         /* Cannot call dma_free_coherent() with IRQs disabled */
    1692                 :          0 :                         DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    1693                 :            :                         dwc_otg_ep_free_desc_chain(dev, desc_addr, dma_desc_addr,
    1694                 :            :                                                    MAX_DMA_DESC_CNT);
    1695                 :            : 
    1696                 :            :                         goto out_unlocked;
    1697                 :            :                 }
    1698                 :            :         }
    1699                 :          0 :         DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    1700                 :            : 
    1701                 :            : out_unlocked:
    1702                 :            :         DWC_DEBUGPL(DBG_PCD, "%d %s disabled\n", ep->dwc_ep.num,
    1703                 :            :                     ep->dwc_ep.is_in ? "IN" : "OUT");
    1704                 :            :         return 0;
    1705                 :            : 
    1706                 :            : }
    1707                 :            : 
    1708                 :            : /******************************************************************************/
    1709                 :            : #ifdef DWC_UTE_PER_IO
    1710                 :            : 
    1711                 :            : /**
    1712                 :            :  * Free the request and its extended parts
    1713                 :            :  *
    1714                 :            :  */
    1715                 :            : void dwc_pcd_xiso_ereq_free(dwc_otg_pcd_ep_t * ep, dwc_otg_pcd_request_t * req)
    1716                 :            : {
    1717                 :            :         DWC_FREE(req->ext_req.per_io_frame_descs);
    1718                 :            :         DWC_FREE(req);
    1719                 :            : }
    1720                 :            : 
    1721                 :            : /**
    1722                 :            :  * Start the next request in the endpoint's queue.
    1723                 :            :  *
    1724                 :            :  */
    1725                 :            : int dwc_otg_pcd_xiso_start_next_request(dwc_otg_pcd_t * pcd,
    1726                 :            :                                         dwc_otg_pcd_ep_t * ep)
    1727                 :            : {
    1728                 :            :         int i;
    1729                 :            :         dwc_otg_pcd_request_t *req = NULL;
    1730                 :            :         dwc_ep_t *dwcep = NULL;
    1731                 :            :         struct dwc_iso_xreq_port *ereq = NULL;
    1732                 :            :         struct dwc_iso_pkt_desc_port *ddesc_iso;
    1733                 :            :         uint16_t nat;
    1734                 :            :         depctl_data_t diepctl;
    1735                 :            : 
    1736                 :            :         dwcep = &ep->dwc_ep;
    1737                 :            : 
    1738                 :            :         if (dwcep->xiso_active_xfers > 0) {
    1739                 :            : #if 0   //Disable this to decrease s/w overhead that is crucial for Isoc transfers
    1740                 :            :                 DWC_WARN("There are currently active transfers for EP%d \
    1741                 :            :                                 (active=%d; queued=%d)", dwcep->num, dwcep->xiso_active_xfers,
    1742                 :            :                                 dwcep->xiso_queued_xfers);
    1743                 :            : #endif
    1744                 :            :                 return 0;
    1745                 :            :         }
    1746                 :            : 
    1747                 :            :         nat = UGETW(ep->desc->wMaxPacketSize);
    1748                 :            :         nat = (nat >> 11) & 0x03;
    1749                 :            : 
    1750                 :            :         if (!DWC_CIRCLEQ_EMPTY(&ep->queue)) {
    1751                 :            :                 req = DWC_CIRCLEQ_FIRST(&ep->queue);
    1752                 :            :                 ereq = &req->ext_req;
    1753                 :            :                 ep->stopped = 0;
    1754                 :            : 
    1755                 :            :                 /* Get the frame number */
    1756                 :            :                 dwcep->xiso_frame_num =
    1757                 :            :                     dwc_otg_get_frame_number(GET_CORE_IF(pcd));
    1758                 :            :                 DWC_DEBUG("FRM_NUM=%d", dwcep->xiso_frame_num);
    1759                 :            : 
    1760                 :            :                 ddesc_iso = ereq->per_io_frame_descs;
    1761                 :            : 
    1762                 :            :                 if (dwcep->is_in) {
    1763                 :            :                         /* Setup DMA Descriptor chain for IN Isoc request */
    1764                 :            :                         for (i = 0; i < ereq->pio_pkt_count; i++) {
    1765                 :            :                                 //if ((i % (nat + 1)) == 0)
    1766                 :            :                                 if ( i > 0 )
    1767                 :            :                                         dwcep->xiso_frame_num =
    1768                 :            :                                             (dwcep->xiso_bInterval +
    1769                 :            :                                                                                 dwcep->xiso_frame_num) & 0x3FFF;
    1770                 :            :                                 dwcep->desc_addr[i].buf =
    1771                 :            :                                     req->dma + ddesc_iso[i].offset;
    1772                 :            :                                 dwcep->desc_addr[i].status.b_iso_in.txbytes =
    1773                 :            :                                     ddesc_iso[i].length;
    1774                 :            :                                 dwcep->desc_addr[i].status.b_iso_in.framenum =
    1775                 :            :                                     dwcep->xiso_frame_num;
    1776                 :            :                                 dwcep->desc_addr[i].status.b_iso_in.bs =
    1777                 :            :                                     BS_HOST_READY;
    1778                 :            :                                 dwcep->desc_addr[i].status.b_iso_in.txsts = 0;
    1779                 :            :                                 dwcep->desc_addr[i].status.b_iso_in.sp =
    1780                 :            :                                     (ddesc_iso[i].length %
    1781                 :            :                                      dwcep->maxpacket) ? 1 : 0;
    1782                 :            :                                 dwcep->desc_addr[i].status.b_iso_in.ioc = 0;
    1783                 :            :                                 dwcep->desc_addr[i].status.b_iso_in.pid = nat + 1;
    1784                 :            :                                 dwcep->desc_addr[i].status.b_iso_in.l = 0;
    1785                 :            : 
    1786                 :            :                                 /* Process the last descriptor */
    1787                 :            :                                 if (i == ereq->pio_pkt_count - 1) {
    1788                 :            :                                         dwcep->desc_addr[i].status.b_iso_in.ioc = 1;
    1789                 :            :                                         dwcep->desc_addr[i].status.b_iso_in.l = 1;
    1790                 :            :                                 }
    1791                 :            :                         }
    1792                 :            : 
    1793                 :            :                         /* Setup and start the transfer for this endpoint */
    1794                 :            :                         dwcep->xiso_active_xfers++;
    1795                 :            :                         DWC_WRITE_REG32(&GET_CORE_IF(pcd)->dev_if->
    1796                 :            :                                         in_ep_regs[dwcep->num]->diepdma,
    1797                 :            :                                         dwcep->dma_desc_addr);
    1798                 :            :                         diepctl.d32 = 0;
    1799                 :            :                         diepctl.b.epena = 1;
    1800                 :            :                         diepctl.b.cnak = 1;
    1801                 :            :                         DWC_MODIFY_REG32(&GET_CORE_IF(pcd)->dev_if->
    1802                 :            :                                          in_ep_regs[dwcep->num]->diepctl, 0,
    1803                 :            :                                          diepctl.d32);
    1804                 :            :                 } else {
    1805                 :            :                         /* Setup DMA Descriptor chain for OUT Isoc request */
    1806                 :            :                         for (i = 0; i < ereq->pio_pkt_count; i++) {
    1807                 :            :                                 //if ((i % (nat + 1)) == 0)
    1808                 :            :                                 dwcep->xiso_frame_num = (dwcep->xiso_bInterval +
    1809                 :            :                                                                                 dwcep->xiso_frame_num) & 0x3FFF;
    1810                 :            :                                 dwcep->desc_addr[i].buf =
    1811                 :            :                                     req->dma + ddesc_iso[i].offset;
    1812                 :            :                                 dwcep->desc_addr[i].status.b_iso_out.rxbytes =
    1813                 :            :                                     ddesc_iso[i].length;
    1814                 :            :                                 dwcep->desc_addr[i].status.b_iso_out.framenum =
    1815                 :            :                                     dwcep->xiso_frame_num;
    1816                 :            :                                 dwcep->desc_addr[i].status.b_iso_out.bs =
    1817                 :            :                                     BS_HOST_READY;
    1818                 :            :                                 dwcep->desc_addr[i].status.b_iso_out.rxsts = 0;
    1819                 :            :                                 dwcep->desc_addr[i].status.b_iso_out.sp =
    1820                 :            :                                     (ddesc_iso[i].length %
    1821                 :            :                                      dwcep->maxpacket) ? 1 : 0;
    1822                 :            :                                 dwcep->desc_addr[i].status.b_iso_out.ioc = 0;
    1823                 :            :                                 dwcep->desc_addr[i].status.b_iso_out.pid = nat + 1;
    1824                 :            :                                 dwcep->desc_addr[i].status.b_iso_out.l = 0;
    1825                 :            : 
    1826                 :            :                                 /* Process the last descriptor */
    1827                 :            :                                 if (i == ereq->pio_pkt_count - 1) {
    1828                 :            :                                         dwcep->desc_addr[i].status.b_iso_out.ioc = 1;
    1829                 :            :                                         dwcep->desc_addr[i].status.b_iso_out.l = 1;
    1830                 :            :                                 }
    1831                 :            :                         }
    1832                 :            : 
    1833                 :            :                         /* Setup and start the transfer for this endpoint */
    1834                 :            :                         dwcep->xiso_active_xfers++;
    1835                 :            :                         DWC_WRITE_REG32(&GET_CORE_IF(pcd)->
    1836                 :            :                                         dev_if->out_ep_regs[dwcep->num]->
    1837                 :            :                                         doepdma, dwcep->dma_desc_addr);
    1838                 :            :                         diepctl.d32 = 0;
    1839                 :            :                         diepctl.b.epena = 1;
    1840                 :            :                         diepctl.b.cnak = 1;
    1841                 :            :                         DWC_MODIFY_REG32(&GET_CORE_IF(pcd)->
    1842                 :            :                                          dev_if->out_ep_regs[dwcep->num]->
    1843                 :            :                                          doepctl, 0, diepctl.d32);
    1844                 :            :                 }
    1845                 :            : 
    1846                 :            :         } else {
    1847                 :            :                 ep->stopped = 1;
    1848                 :            :         }
    1849                 :            : 
    1850                 :            :         return 0;
    1851                 :            : }
    1852                 :            : 
    1853                 :            : /**
    1854                 :            :  *      - Remove the request from the queue
    1855                 :            :  */
    1856                 :            : void complete_xiso_ep(dwc_otg_pcd_ep_t * ep)
    1857                 :            : {
    1858                 :            :         dwc_otg_pcd_request_t *req = NULL;
    1859                 :            :         struct dwc_iso_xreq_port *ereq = NULL;
    1860                 :            :         struct dwc_iso_pkt_desc_port *ddesc_iso = NULL;
    1861                 :            :         dwc_ep_t *dwcep = NULL;
    1862                 :            :         int i;
    1863                 :            : 
    1864                 :            :         //DWC_DEBUG();
    1865                 :            :         dwcep = &ep->dwc_ep;
    1866                 :            : 
    1867                 :            :         /* Get the first pending request from the queue */
    1868                 :            :         if (!DWC_CIRCLEQ_EMPTY(&ep->queue)) {
    1869                 :            :                 req = DWC_CIRCLEQ_FIRST(&ep->queue);
    1870                 :            :                 if (!req) {
    1871                 :            :                         DWC_PRINTF("complete_ep 0x%p, req = NULL!\n", ep);
    1872                 :            :                         return;
    1873                 :            :                 }
    1874                 :            :                 dwcep->xiso_active_xfers--;
    1875                 :            :                 dwcep->xiso_queued_xfers--;
    1876                 :            :                 /* Remove this request from the queue */
    1877                 :            :                 DWC_CIRCLEQ_REMOVE_INIT(&ep->queue, req, queue_entry);
    1878                 :            :         } else {
    1879                 :            :                 DWC_PRINTF("complete_ep 0x%p, ep->queue empty!\n", ep);
    1880                 :            :                 return;
    1881                 :            :         }
    1882                 :            : 
    1883                 :            :         ep->stopped = 1;
    1884                 :            :         ereq = &req->ext_req;
    1885                 :            :         ddesc_iso = ereq->per_io_frame_descs;
    1886                 :            : 
    1887                 :            :         if (dwcep->xiso_active_xfers < 0) {
    1888                 :            :                 DWC_WARN("EP#%d (xiso_active_xfers=%d)", dwcep->num,
    1889                 :            :                          dwcep->xiso_active_xfers);
    1890                 :            :         }
    1891                 :            : 
    1892                 :            :         /* Fill the Isoc descs of portable extended req from dma descriptors */
    1893                 :            :         for (i = 0; i < ereq->pio_pkt_count; i++) {
    1894                 :            :                 if (dwcep->is_in) {  /* IN endpoints */
    1895                 :            :                         ddesc_iso[i].actual_length = ddesc_iso[i].length -
    1896                 :            :                             dwcep->desc_addr[i].status.b_iso_in.txbytes;
    1897                 :            :                         ddesc_iso[i].status =
    1898                 :            :                             dwcep->desc_addr[i].status.b_iso_in.txsts;
    1899                 :            :                 } else {        /* OUT endpoints */
    1900                 :            :                         ddesc_iso[i].actual_length = ddesc_iso[i].length -
    1901                 :            :                             dwcep->desc_addr[i].status.b_iso_out.rxbytes;
    1902                 :            :                         ddesc_iso[i].status =
    1903                 :            :                             dwcep->desc_addr[i].status.b_iso_out.rxsts;
    1904                 :            :                 }
    1905                 :            :         }
    1906                 :            : 
    1907                 :            :         DWC_SPINUNLOCK(ep->pcd->lock);
    1908                 :            : 
    1909                 :            :         /* Call the completion function in the non-portable logic */
    1910                 :            :         ep->pcd->fops->xisoc_complete(ep->pcd, ep->priv, req->priv, 0,
    1911                 :            :                                       &req->ext_req);
    1912                 :            : 
    1913                 :            :         DWC_SPINLOCK(ep->pcd->lock);
    1914                 :            : 
    1915                 :            :         /* Free the request - specific freeing needed for extended request object */
    1916                 :            :         dwc_pcd_xiso_ereq_free(ep, req);
    1917                 :            : 
    1918                 :            :         /* Start the next request */
    1919                 :            :         dwc_otg_pcd_xiso_start_next_request(ep->pcd, ep);
    1920                 :            : 
    1921                 :            :         return;
    1922                 :            : }
    1923                 :            : 
    1924                 :            : /**
    1925                 :            :  * Create and initialize the Isoc pkt descriptors of the extended request.
    1926                 :            :  *
    1927                 :            :  */
    1928                 :            : static int dwc_otg_pcd_xiso_create_pkt_descs(dwc_otg_pcd_request_t * req,
    1929                 :            :                                              void *ereq_nonport,
    1930                 :            :                                              int atomic_alloc)
    1931                 :            : {
    1932                 :            :         struct dwc_iso_xreq_port *ereq = NULL;
    1933                 :            :         struct dwc_iso_xreq_port *req_mapped = NULL;
    1934                 :            :         struct dwc_iso_pkt_desc_port *ipds = NULL;      /* To be created in this function */
    1935                 :            :         uint32_t pkt_count;
    1936                 :            :         int i;
    1937                 :            : 
    1938                 :            :         ereq = &req->ext_req;
    1939                 :            :         req_mapped = (struct dwc_iso_xreq_port *)ereq_nonport;
    1940                 :            :         pkt_count = req_mapped->pio_pkt_count;
    1941                 :            : 
    1942                 :            :         /* Create the isoc descs */
    1943                 :            :         if (atomic_alloc) {
    1944                 :            :                 ipds = DWC_ALLOC_ATOMIC(sizeof(*ipds) * pkt_count);
    1945                 :            :         } else {
    1946                 :            :                 ipds = DWC_ALLOC(sizeof(*ipds) * pkt_count);
    1947                 :            :         }
    1948                 :            : 
    1949                 :            :         if (!ipds) {
    1950                 :            :                 DWC_ERROR("Failed to allocate isoc descriptors");
    1951                 :            :                 return -DWC_E_NO_MEMORY;
    1952                 :            :         }
    1953                 :            : 
    1954                 :            :         /* Initialize the extended request fields */
    1955                 :            :         ereq->per_io_frame_descs = ipds;
    1956                 :            :         ereq->error_count = 0;
    1957                 :            :         ereq->pio_alloc_pkt_count = pkt_count;
    1958                 :            :         ereq->pio_pkt_count = pkt_count;
    1959                 :            :         ereq->tr_sub_flags = req_mapped->tr_sub_flags;
    1960                 :            : 
    1961                 :            :         /* Init the Isoc descriptors */
    1962                 :            :         for (i = 0; i < pkt_count; i++) {
    1963                 :            :                 ipds[i].length = req_mapped->per_io_frame_descs[i].length;
    1964                 :            :                 ipds[i].offset = req_mapped->per_io_frame_descs[i].offset;
    1965                 :            :                 ipds[i].status = req_mapped->per_io_frame_descs[i].status;   /* 0 */
    1966                 :            :                 ipds[i].actual_length =
    1967                 :            :                     req_mapped->per_io_frame_descs[i].actual_length;
    1968                 :            :         }
    1969                 :            : 
    1970                 :            :         return 0;
    1971                 :            : }
    1972                 :            : 
    1973                 :            : static void prn_ext_request(struct dwc_iso_xreq_port *ereq)
    1974                 :            : {
    1975                 :            :         struct dwc_iso_pkt_desc_port *xfd = NULL;
    1976                 :            :         int i;
    1977                 :            : 
    1978                 :            :         DWC_DEBUG("per_io_frame_descs=%p", ereq->per_io_frame_descs);
    1979                 :            :         DWC_DEBUG("tr_sub_flags=%d", ereq->tr_sub_flags);
    1980                 :            :         DWC_DEBUG("error_count=%d", ereq->error_count);
    1981                 :            :         DWC_DEBUG("pio_alloc_pkt_count=%d", ereq->pio_alloc_pkt_count);
    1982                 :            :         DWC_DEBUG("pio_pkt_count=%d", ereq->pio_pkt_count);
    1983                 :            :         DWC_DEBUG("res=%d", ereq->res);
    1984                 :            : 
    1985                 :            :         for (i = 0; i < ereq->pio_pkt_count; i++) {
    1986                 :            :                 xfd = &ereq->per_io_frame_descs[0];
    1987                 :            :                 DWC_DEBUG("FD #%d", i);
    1988                 :            : 
    1989                 :            :                 DWC_DEBUG("xfd->actual_length=%d", xfd->actual_length);
    1990                 :            :                 DWC_DEBUG("xfd->length=%d", xfd->length);
    1991                 :            :                 DWC_DEBUG("xfd->offset=%d", xfd->offset);
    1992                 :            :                 DWC_DEBUG("xfd->status=%d", xfd->status);
    1993                 :            :         }
    1994                 :            : }
    1995                 :            : 
    1996                 :            : /**
    1997                 :            :  *
    1998                 :            :  */
    1999                 :            : int dwc_otg_pcd_xiso_ep_queue(dwc_otg_pcd_t * pcd, void *ep_handle,
    2000                 :            :                               uint8_t * buf, dwc_dma_t dma_buf, uint32_t buflen,
    2001                 :            :                               int zero, void *req_handle, int atomic_alloc,
    2002                 :            :                               void *ereq_nonport)
    2003                 :            : {
    2004                 :            :         dwc_otg_pcd_request_t *req = NULL;
    2005                 :            :         dwc_otg_pcd_ep_t *ep;
    2006                 :            :         dwc_irqflags_t flags;
    2007                 :            :         int res;
    2008                 :            : 
    2009                 :            :         ep = get_ep_from_handle(pcd, ep_handle);
    2010                 :            :         if (!ep) {
    2011                 :            :                 DWC_WARN("bad ep\n");
    2012                 :            :                 return -DWC_E_INVALID;
    2013                 :            :         }
    2014                 :            : 
    2015                 :            :         /* We support this extension only for DDMA mode */
    2016                 :            :         if (ep->dwc_ep.type == DWC_OTG_EP_TYPE_ISOC)
    2017                 :            :                 if (!GET_CORE_IF(pcd)->dma_desc_enable)
    2018                 :            :                         return -DWC_E_INVALID;
    2019                 :            : 
    2020                 :            :         /* Create a dwc_otg_pcd_request_t object */
    2021                 :            :         if (atomic_alloc) {
    2022                 :            :                 req = DWC_ALLOC_ATOMIC(sizeof(*req));
    2023                 :            :         } else {
    2024                 :            :                 req = DWC_ALLOC(sizeof(*req));
    2025                 :            :         }
    2026                 :            : 
    2027                 :            :         if (!req) {
    2028                 :            :                 return -DWC_E_NO_MEMORY;
    2029                 :            :         }
    2030                 :            : 
    2031                 :            :         /* Create the Isoc descs for this request which shall be the exact match
    2032                 :            :          * of the structure sent to us from the non-portable logic */
    2033                 :            :         res =
    2034                 :            :             dwc_otg_pcd_xiso_create_pkt_descs(req, ereq_nonport, atomic_alloc);
    2035                 :            :         if (res) {
    2036                 :            :                 DWC_WARN("Failed to init the Isoc descriptors");
    2037                 :            :                 DWC_FREE(req);
    2038                 :            :                 return res;
    2039                 :            :         }
    2040                 :            : 
    2041                 :            :         DWC_SPINLOCK_IRQSAVE(pcd->lock, &flags);
    2042                 :            : 
    2043                 :            :         DWC_CIRCLEQ_INIT_ENTRY(req, queue_entry);
    2044                 :            :         req->buf = buf;
    2045                 :            :         req->dma = dma_buf;
    2046                 :            :         req->length = buflen;
    2047                 :            :         req->sent_zlp = zero;
    2048                 :            :         req->priv = req_handle;
    2049                 :            : 
    2050                 :            :         //DWC_SPINLOCK_IRQSAVE(pcd->lock, &flags);
    2051                 :            :         ep->dwc_ep.dma_addr = dma_buf;
    2052                 :            :         ep->dwc_ep.start_xfer_buff = buf;
    2053                 :            :         ep->dwc_ep.xfer_buff = buf;
    2054                 :            :         ep->dwc_ep.xfer_len = 0;
    2055                 :            :         ep->dwc_ep.xfer_count = 0;
    2056                 :            :         ep->dwc_ep.sent_zlp = 0;
    2057                 :            :         ep->dwc_ep.total_len = buflen;
    2058                 :            : 
    2059                 :            :         /* Add this request to the tail */
    2060                 :            :         DWC_CIRCLEQ_INSERT_TAIL(&ep->queue, req, queue_entry);
    2061                 :            :         ep->dwc_ep.xiso_queued_xfers++;
    2062                 :            : 
    2063                 :            : //DWC_DEBUG("CP_0");
    2064                 :            : //DWC_DEBUG("req->ext_req.tr_sub_flags=%d", req->ext_req.tr_sub_flags);
    2065                 :            : //prn_ext_request((struct dwc_iso_xreq_port *) ereq_nonport);
    2066                 :            : //prn_ext_request(&req->ext_req);
    2067                 :            : 
    2068                 :            :         //DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    2069                 :            : 
    2070                 :            :         /* If the req->status == ASAP  then check if there is any active transfer
    2071                 :            :          * for this endpoint. If no active transfers, then get the first entry
    2072                 :            :          * from the queue and start that transfer
    2073                 :            :          */
    2074                 :            :         if (req->ext_req.tr_sub_flags == DWC_EREQ_TF_ASAP) {
    2075                 :            :                 res = dwc_otg_pcd_xiso_start_next_request(pcd, ep);
    2076                 :            :                 if (res) {
    2077                 :            :                         DWC_WARN("Failed to start the next Isoc transfer");
    2078                 :            :                         DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    2079                 :            :                         DWC_FREE(req);
    2080                 :            :                         return res;
    2081                 :            :                 }
    2082                 :            :         }
    2083                 :            : 
    2084                 :            :         DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    2085                 :            :         return 0;
    2086                 :            : }
    2087                 :            : 
    2088                 :            : #endif
    2089                 :            : /* END ifdef DWC_UTE_PER_IO ***************************************************/
    2090                 :          0 : int dwc_otg_pcd_ep_queue(dwc_otg_pcd_t * pcd, void *ep_handle,
    2091                 :            :                          uint8_t * buf, dwc_dma_t dma_buf, uint32_t buflen,
    2092                 :            :                          int zero, void *req_handle, int atomic_alloc)
    2093                 :            : {
    2094                 :            :         struct device *dev = dwc_otg_pcd_to_dev(pcd);
    2095                 :            :         dwc_irqflags_t flags;
    2096                 :            :         dwc_otg_pcd_request_t *req;
    2097                 :            :         dwc_otg_pcd_ep_t *ep;
    2098                 :            :         uint32_t max_transfer;
    2099                 :            : 
    2100                 :            :         ep = get_ep_from_handle(pcd, ep_handle);
    2101                 :          0 :         if (!ep || (!ep->desc && ep->dwc_ep.num != 0)) {
    2102                 :          0 :                 DWC_WARN("bad ep\n");
    2103                 :          0 :                 return -DWC_E_INVALID;
    2104                 :            :         }
    2105                 :            : 
    2106                 :          0 :         if (atomic_alloc) {
    2107                 :          0 :                 req = DWC_ALLOC_ATOMIC(sizeof(*req));
    2108                 :            :         } else {
    2109                 :          0 :                 req = DWC_ALLOC(sizeof(*req));
    2110                 :            :         }
    2111                 :            : 
    2112                 :          0 :         if (!req) {
    2113                 :            :                 return -DWC_E_NO_MEMORY;
    2114                 :            :         }
    2115                 :          0 :         DWC_CIRCLEQ_INIT_ENTRY(req, queue_entry);
    2116                 :          0 :         if (!GET_CORE_IF(pcd)->core_params->opt) {
    2117                 :          0 :                 if (ep->dwc_ep.num != 0) {
    2118                 :          0 :                         DWC_ERROR("queue req %p, len %d buf %p\n",
    2119                 :            :                                   req_handle, buflen, buf);
    2120                 :            :                 }
    2121                 :            :         }
    2122                 :            : 
    2123                 :          0 :         req->buf = buf;
    2124                 :          0 :         req->dma = dma_buf;
    2125                 :          0 :         req->length = buflen;
    2126                 :          0 :         req->sent_zlp = zero;
    2127                 :          0 :         req->priv = req_handle;
    2128                 :          0 :         req->dw_align_buf = NULL;
    2129                 :          0 :         if ((dma_buf & 0x3) && GET_CORE_IF(pcd)->dma_enable
    2130                 :          0 :                         && !GET_CORE_IF(pcd)->dma_desc_enable)
    2131                 :          0 :                 req->dw_align_buf = DWC_DMA_ALLOC(dev, buflen,
    2132                 :            :                                  &req->dw_align_buf_dma);
    2133                 :          0 :         DWC_SPINLOCK_IRQSAVE(pcd->lock, &flags);
    2134                 :            : 
    2135                 :            :         /*
    2136                 :            :          * After adding request to the queue for IN ISOC wait for In Token Received
    2137                 :            :          * when TX FIFO is empty interrupt and for OUT ISOC wait for OUT Token
    2138                 :            :          * Received when EP is disabled interrupt to obtain starting microframe
    2139                 :            :          * (odd/even) start transfer
    2140                 :            :          */
    2141                 :          0 :         if (ep->dwc_ep.type == DWC_OTG_EP_TYPE_ISOC) {
    2142                 :          0 :                 if (req != 0) {
    2143                 :          0 :                         depctl_data_t depctl = {.d32 =
    2144                 :          0 :                                     DWC_READ_REG32(&pcd->core_if->dev_if->
    2145                 :          0 :                                                    in_ep_regs[ep->dwc_ep.num]->
    2146                 :            :                                                    diepctl) };
    2147                 :          0 :                         ++pcd->request_pending;
    2148                 :            : 
    2149                 :          0 :                         DWC_CIRCLEQ_INSERT_TAIL(&ep->queue, req, queue_entry);
    2150                 :          0 :                         if (ep->dwc_ep.is_in) {
    2151                 :          0 :                                 depctl.b.cnak = 1;
    2152                 :          0 :                                 DWC_WRITE_REG32(&pcd->core_if->dev_if->
    2153                 :          0 :                                                 in_ep_regs[ep->dwc_ep.num]->
    2154                 :            :                                                 diepctl, depctl.d32);
    2155                 :            :                         }
    2156                 :            : 
    2157                 :          0 :                         DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    2158                 :            :                 }
    2159                 :            :                 return 0;
    2160                 :            :         }
    2161                 :            : 
    2162                 :            :         /*
    2163                 :            :          * For EP0 IN without premature status, zlp is required?
    2164                 :            :          */
    2165                 :            :         if (ep->dwc_ep.num == 0 && ep->dwc_ep.is_in) {
    2166                 :            :                 DWC_DEBUGPL(DBG_PCDV, "%d-OUT ZLP\n", ep->dwc_ep.num);
    2167                 :            :                 //_req->zero = 1;
    2168                 :            :         }
    2169                 :            : 
    2170                 :            :         /* Start the transfer */
    2171                 :          0 :         if (DWC_CIRCLEQ_EMPTY(&ep->queue) && !ep->stopped) {
    2172                 :            :                 /* EP0 Transfer? */
    2173                 :          0 :                 if (ep->dwc_ep.num == 0) {
    2174                 :          0 :                         switch (pcd->ep0state) {
    2175                 :            :                         case EP0_IN_DATA_PHASE:
    2176                 :            :                                 DWC_DEBUGPL(DBG_PCD,
    2177                 :            :                                             "%s ep0: EP0_IN_DATA_PHASE\n",
    2178                 :            :                                             __func__);
    2179                 :            :                                 break;
    2180                 :            : 
    2181                 :            :                         case EP0_OUT_DATA_PHASE:
    2182                 :            :                                 DWC_DEBUGPL(DBG_PCD,
    2183                 :            :                                             "%s ep0: EP0_OUT_DATA_PHASE\n",
    2184                 :            :                                             __func__);
    2185                 :          0 :                                 if (pcd->request_config) {
    2186                 :            :                                         /* Complete STATUS PHASE */
    2187                 :          0 :                                         ep->dwc_ep.is_in = 1;
    2188                 :          0 :                                         pcd->ep0state = EP0_IN_STATUS_PHASE;
    2189                 :            :                                 }
    2190                 :            :                                 break;
    2191                 :            : 
    2192                 :            :                         case EP0_IN_STATUS_PHASE:
    2193                 :            :                                 DWC_DEBUGPL(DBG_PCD,
    2194                 :            :                                             "%s ep0: EP0_IN_STATUS_PHASE\n",
    2195                 :            :                                             __func__);
    2196                 :            :                                 break;
    2197                 :            : 
    2198                 :            :                         default:
    2199                 :            :                                 DWC_DEBUGPL(DBG_ANY, "ep0: odd state %d\n",
    2200                 :            :                                             pcd->ep0state);
    2201                 :          0 :                                 DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    2202                 :          0 :                                 return -DWC_E_SHUTDOWN;
    2203                 :            :                         }
    2204                 :            : 
    2205                 :          0 :                         ep->dwc_ep.dma_addr = dma_buf;
    2206                 :          0 :                         ep->dwc_ep.start_xfer_buff = buf;
    2207                 :          0 :                         ep->dwc_ep.xfer_buff = buf;
    2208                 :          0 :                         ep->dwc_ep.xfer_len = buflen;
    2209                 :          0 :                         ep->dwc_ep.xfer_count = 0;
    2210                 :          0 :                         ep->dwc_ep.sent_zlp = 0;
    2211                 :          0 :                         ep->dwc_ep.total_len = ep->dwc_ep.xfer_len;
    2212                 :            : 
    2213                 :          0 :                         if (zero) {
    2214                 :          0 :                                 if ((ep->dwc_ep.xfer_len %
    2215                 :          0 :                                      ep->dwc_ep.maxpacket == 0)
    2216                 :          0 :                                     && (ep->dwc_ep.xfer_len != 0)) {
    2217                 :          0 :                                         ep->dwc_ep.sent_zlp = 1;
    2218                 :            :                                 }
    2219                 :            : 
    2220                 :            :                         }
    2221                 :            : 
    2222                 :          0 :                         dwc_otg_ep0_start_transfer(GET_CORE_IF(pcd),
    2223                 :            :                                                    &ep->dwc_ep);
    2224                 :            :                 }               // non-ep0 endpoints
    2225                 :            :                 else {
    2226                 :            : #ifdef DWC_UTE_CFI
    2227                 :            :                         if (ep->dwc_ep.buff_mode != BM_STANDARD) {
    2228                 :            :                                 /* store the request length */
    2229                 :            :                                 ep->dwc_ep.cfi_req_len = buflen;
    2230                 :            :                                 pcd->cfi->ops.build_descriptors(pcd->cfi, pcd,
    2231                 :            :                                                                 ep, req);
    2232                 :            :                         } else {
    2233                 :            : #endif
    2234                 :          0 :                                 max_transfer =
    2235                 :          0 :                                     GET_CORE_IF(ep->pcd)->core_params->
    2236                 :            :                                     max_transfer_size;
    2237                 :            : 
    2238                 :            :                                 /* Setup and start the Transfer */
    2239                 :          0 :                                 if (req->dw_align_buf){
    2240                 :          0 :                                         if (ep->dwc_ep.is_in)
    2241                 :          0 :                                                 dwc_memcpy(req->dw_align_buf,
    2242                 :            :                                                            buf, buflen);
    2243                 :          0 :                                         ep->dwc_ep.dma_addr =
    2244                 :          0 :                                             req->dw_align_buf_dma;
    2245                 :          0 :                                         ep->dwc_ep.start_xfer_buff =
    2246                 :          0 :                                             req->dw_align_buf;
    2247                 :          0 :                                         ep->dwc_ep.xfer_buff =
    2248                 :          0 :                                             req->dw_align_buf;
    2249                 :            :                                 } else {
    2250                 :          0 :                                         ep->dwc_ep.dma_addr = dma_buf;
    2251                 :          0 :                                         ep->dwc_ep.start_xfer_buff = buf;
    2252                 :          0 :                                         ep->dwc_ep.xfer_buff = buf;
    2253                 :            :                                 }
    2254                 :          0 :                                 ep->dwc_ep.xfer_len = 0;
    2255                 :          0 :                                 ep->dwc_ep.xfer_count = 0;
    2256                 :          0 :                                 ep->dwc_ep.sent_zlp = 0;
    2257                 :          0 :                                 ep->dwc_ep.total_len = buflen;
    2258                 :            : 
    2259                 :          0 :                                 ep->dwc_ep.maxxfer = max_transfer;
    2260                 :          0 :                                 if (GET_CORE_IF(pcd)->dma_desc_enable) {
    2261                 :            :                                         uint32_t out_max_xfer =
    2262                 :            :                                             DDMA_MAX_TRANSFER_SIZE -
    2263                 :            :                                             (DDMA_MAX_TRANSFER_SIZE % 4);
    2264                 :          0 :                                         if (ep->dwc_ep.is_in) {
    2265                 :          0 :                                                 if (ep->dwc_ep.maxxfer >
    2266                 :            :                                                     DDMA_MAX_TRANSFER_SIZE) {
    2267                 :          0 :                                                         ep->dwc_ep.maxxfer =
    2268                 :            :                                                             DDMA_MAX_TRANSFER_SIZE;
    2269                 :            :                                                 }
    2270                 :            :                                         } else {
    2271                 :          0 :                                                 if (ep->dwc_ep.maxxfer >
    2272                 :            :                                                     out_max_xfer) {
    2273                 :          0 :                                                         ep->dwc_ep.maxxfer =
    2274                 :            :                                                             out_max_xfer;
    2275                 :            :                                                 }
    2276                 :            :                                         }
    2277                 :            :                                 }
    2278                 :          0 :                                 if (ep->dwc_ep.maxxfer < ep->dwc_ep.total_len) {
    2279                 :          0 :                                         ep->dwc_ep.maxxfer -=
    2280                 :          0 :                                             (ep->dwc_ep.maxxfer %
    2281                 :          0 :                                              ep->dwc_ep.maxpacket);
    2282                 :            :                                 }
    2283                 :            : 
    2284                 :          0 :                                 if (zero) {
    2285                 :          0 :                                         if ((ep->dwc_ep.total_len %
    2286                 :          0 :                                              ep->dwc_ep.maxpacket == 0)
    2287                 :          0 :                                             && (ep->dwc_ep.total_len != 0)) {
    2288                 :          0 :                                                 ep->dwc_ep.sent_zlp = 1;
    2289                 :            :                                         }
    2290                 :            :                                 }
    2291                 :            : #ifdef DWC_UTE_CFI
    2292                 :            :                         }
    2293                 :            : #endif
    2294                 :          0 :                         dwc_otg_ep_start_transfer(GET_CORE_IF(pcd),
    2295                 :            :                                                   &ep->dwc_ep);
    2296                 :            :                 }
    2297                 :            :         }
    2298                 :            : 
    2299                 :          0 :         if (req != 0) {
    2300                 :          0 :                 ++pcd->request_pending;
    2301                 :          0 :                 DWC_CIRCLEQ_INSERT_TAIL(&ep->queue, req, queue_entry);
    2302                 :          0 :                 if (ep->dwc_ep.is_in && ep->stopped
    2303                 :          0 :                     && !(GET_CORE_IF(pcd)->dma_enable)) {
    2304                 :            :                         /** @todo NGS Create a function for this. */
    2305                 :          0 :                         diepmsk_data_t diepmsk = {.d32 = 0 };
    2306                 :          0 :                         diepmsk.b.intktxfemp = 1;
    2307                 :          0 :                         if (GET_CORE_IF(pcd)->multiproc_int_enable) {
    2308                 :          0 :                                 DWC_MODIFY_REG32(&GET_CORE_IF(pcd)->
    2309                 :          0 :                                                  dev_if->dev_global_regs->diepeachintmsk
    2310                 :          0 :                                                  [ep->dwc_ep.num], 0,
    2311                 :            :                                                  diepmsk.d32);
    2312                 :            :                         } else {
    2313                 :          0 :                                 DWC_MODIFY_REG32(&GET_CORE_IF(pcd)->
    2314                 :          0 :                                                  dev_if->dev_global_regs->
    2315                 :            :                                                  diepmsk, 0, diepmsk.d32);
    2316                 :            :                         }
    2317                 :            : 
    2318                 :            :                 }
    2319                 :            :         }
    2320                 :          0 :         DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    2321                 :            : 
    2322                 :          0 :         return 0;
    2323                 :            : }
    2324                 :            : 
    2325                 :          0 : int dwc_otg_pcd_ep_dequeue(dwc_otg_pcd_t * pcd, void *ep_handle,
    2326                 :            :                            void *req_handle)
    2327                 :            : {
    2328                 :            :         dwc_irqflags_t flags;
    2329                 :            :         dwc_otg_pcd_request_t *req;
    2330                 :            :         dwc_otg_pcd_ep_t *ep;
    2331                 :            : 
    2332                 :            :         ep = get_ep_from_handle(pcd, ep_handle);
    2333                 :          0 :         if (!ep || (!ep->desc && ep->dwc_ep.num != 0)) {
    2334                 :          0 :                 DWC_WARN("bad argument\n");
    2335                 :          0 :                 return -DWC_E_INVALID;
    2336                 :            :         }
    2337                 :            : 
    2338                 :          0 :         DWC_SPINLOCK_IRQSAVE(pcd->lock, &flags);
    2339                 :            : 
    2340                 :            :         /* make sure it's actually queued on this endpoint */
    2341                 :          0 :         DWC_CIRCLEQ_FOREACH(req, &ep->queue, queue_entry) {
    2342                 :          0 :                 if (req->priv == (void *)req_handle) {
    2343                 :            :                         break;
    2344                 :            :                 }
    2345                 :            :         }
    2346                 :            : 
    2347                 :          0 :         if (req->priv != (void *)req_handle) {
    2348                 :          0 :                 DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    2349                 :          0 :                 return -DWC_E_INVALID;
    2350                 :            :         }
    2351                 :            : 
    2352                 :          0 :         if (!DWC_CIRCLEQ_EMPTY_ENTRY(req, queue_entry)) {
    2353                 :          0 :                 dwc_otg_request_done(ep, req, -DWC_E_RESTART);
    2354                 :            :         } else {
    2355                 :            :                 req = NULL;
    2356                 :            :         }
    2357                 :            : 
    2358                 :          0 :         DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    2359                 :            : 
    2360                 :          0 :         return req ? 0 : -DWC_E_SHUTDOWN;
    2361                 :            : 
    2362                 :            : }
    2363                 :            : 
    2364                 :            : /**
    2365                 :            :  * dwc_otg_pcd_ep_wedge - sets the halt feature and ignores clear requests
    2366                 :            :  *
    2367                 :            :  * Use this to stall an endpoint and ignore CLEAR_FEATURE(HALT_ENDPOINT)
    2368                 :            :  * requests. If the gadget driver clears the halt status, it will
    2369                 :            :  * automatically unwedge the endpoint.
    2370                 :            :  *
    2371                 :            :  * Returns zero on success, else negative DWC error code.
    2372                 :            :  */
    2373                 :          0 : int dwc_otg_pcd_ep_wedge(dwc_otg_pcd_t * pcd, void *ep_handle)
    2374                 :            : {
    2375                 :            :         dwc_otg_pcd_ep_t *ep;
    2376                 :            :         dwc_irqflags_t flags;
    2377                 :            :         int retval = 0;
    2378                 :            : 
    2379                 :            :         ep = get_ep_from_handle(pcd, ep_handle);
    2380                 :            : 
    2381                 :          0 :         if ((!ep->desc && ep != &pcd->ep0) ||
    2382                 :          0 :             (ep->desc && (ep->desc->bmAttributes == UE_ISOCHRONOUS))) {
    2383                 :          0 :                 DWC_WARN("%s, bad ep\n", __func__);
    2384                 :          0 :                 return -DWC_E_INVALID;
    2385                 :            :         }
    2386                 :            : 
    2387                 :          0 :         DWC_SPINLOCK_IRQSAVE(pcd->lock, &flags);
    2388                 :          0 :         if (!DWC_CIRCLEQ_EMPTY(&ep->queue)) {
    2389                 :          0 :                 DWC_WARN("%d %s XFer In process\n", ep->dwc_ep.num,
    2390                 :            :                          ep->dwc_ep.is_in ? "IN" : "OUT");
    2391                 :            :                 retval = -DWC_E_AGAIN;
    2392                 :            :         } else {
    2393                 :            :                 /* This code needs to be reviewed */
    2394                 :          0 :                 if (ep->dwc_ep.is_in == 1 && GET_CORE_IF(pcd)->dma_desc_enable) {
    2395                 :            :                         dtxfsts_data_t txstatus;
    2396                 :            :                         fifosize_data_t txfifosize;
    2397                 :            : 
    2398                 :          0 :                         txfifosize.d32 =
    2399                 :          0 :                             DWC_READ_REG32(&GET_CORE_IF(pcd)->
    2400                 :          0 :                                            core_global_regs->dtxfsiz[ep->dwc_ep.
    2401                 :            :                                                                      tx_fifo_num]);
    2402                 :          0 :                         txstatus.d32 =
    2403                 :          0 :                             DWC_READ_REG32(&GET_CORE_IF(pcd)->
    2404                 :          0 :                                            dev_if->in_ep_regs[ep->dwc_ep.num]->
    2405                 :            :                                            dtxfsts);
    2406                 :            : 
    2407                 :          0 :                         if (txstatus.b.txfspcavail < txfifosize.b.depth) {
    2408                 :          0 :                                 DWC_WARN("%s() Data In Tx Fifo\n", __func__);
    2409                 :            :                                 retval = -DWC_E_AGAIN;
    2410                 :            :                         } else {
    2411                 :          0 :                                 if (ep->dwc_ep.num == 0) {
    2412                 :          0 :                                         pcd->ep0state = EP0_STALL;
    2413                 :            :                                 }
    2414                 :            : 
    2415                 :          0 :                                 ep->stopped = 1;
    2416                 :          0 :                                 dwc_otg_ep_set_stall(GET_CORE_IF(pcd),
    2417                 :            :                                                      &ep->dwc_ep);
    2418                 :            :                         }
    2419                 :            :                 } else {
    2420                 :          0 :                         if (ep->dwc_ep.num == 0) {
    2421                 :          0 :                                 pcd->ep0state = EP0_STALL;
    2422                 :            :                         }
    2423                 :            : 
    2424                 :          0 :                         ep->stopped = 1;
    2425                 :          0 :                         dwc_otg_ep_set_stall(GET_CORE_IF(pcd), &ep->dwc_ep);
    2426                 :            :                 }
    2427                 :            :         }
    2428                 :            : 
    2429                 :          0 :         DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    2430                 :            : 
    2431                 :          0 :         return retval;
    2432                 :            : }
    2433                 :            : 
    2434                 :          0 : int dwc_otg_pcd_ep_halt(dwc_otg_pcd_t * pcd, void *ep_handle, int value)
    2435                 :            : {
    2436                 :            :         dwc_otg_pcd_ep_t *ep;
    2437                 :            :         dwc_irqflags_t flags;
    2438                 :            :         int retval = 0;
    2439                 :            : 
    2440                 :            :         ep = get_ep_from_handle(pcd, ep_handle);
    2441                 :            : 
    2442                 :          0 :         if (!ep || (!ep->desc && ep != &pcd->ep0) ||
    2443                 :          0 :             (ep->desc && (ep->desc->bmAttributes == UE_ISOCHRONOUS))) {
    2444                 :          0 :                 DWC_WARN("%s, bad ep\n", __func__);
    2445                 :          0 :                 return -DWC_E_INVALID;
    2446                 :            :         }
    2447                 :            : 
    2448                 :          0 :         DWC_SPINLOCK_IRQSAVE(pcd->lock, &flags);
    2449                 :          0 :         if (!DWC_CIRCLEQ_EMPTY(&ep->queue)) {
    2450                 :          0 :                 DWC_WARN("%d %s XFer In process\n", ep->dwc_ep.num,
    2451                 :            :                          ep->dwc_ep.is_in ? "IN" : "OUT");
    2452                 :            :                 retval = -DWC_E_AGAIN;
    2453                 :          0 :         } else if (value == 0) {
    2454                 :          0 :                 dwc_otg_ep_clear_stall(GET_CORE_IF(pcd), &ep->dwc_ep);
    2455                 :          0 :         } else if (value == 1) {
    2456                 :          0 :                 if (ep->dwc_ep.is_in == 1 && GET_CORE_IF(pcd)->dma_desc_enable) {
    2457                 :            :                         dtxfsts_data_t txstatus;
    2458                 :            :                         fifosize_data_t txfifosize;
    2459                 :            : 
    2460                 :          0 :                         txfifosize.d32 =
    2461                 :          0 :                             DWC_READ_REG32(&GET_CORE_IF(pcd)->core_global_regs->
    2462                 :          0 :                                            dtxfsiz[ep->dwc_ep.tx_fifo_num]);
    2463                 :          0 :                         txstatus.d32 =
    2464                 :          0 :                             DWC_READ_REG32(&GET_CORE_IF(pcd)->dev_if->
    2465                 :          0 :                                            in_ep_regs[ep->dwc_ep.num]->dtxfsts);
    2466                 :            : 
    2467                 :          0 :                         if (txstatus.b.txfspcavail < txfifosize.b.depth) {
    2468                 :          0 :                                 DWC_WARN("%s() Data In Tx Fifo\n", __func__);
    2469                 :            :                                 retval = -DWC_E_AGAIN;
    2470                 :            :                         } else {
    2471                 :          0 :                                 if (ep->dwc_ep.num == 0) {
    2472                 :          0 :                                         pcd->ep0state = EP0_STALL;
    2473                 :            :                                 }
    2474                 :            : 
    2475                 :          0 :                                 ep->stopped = 1;
    2476                 :          0 :                                 dwc_otg_ep_set_stall(GET_CORE_IF(pcd),
    2477                 :            :                                                      &ep->dwc_ep);
    2478                 :            :                         }
    2479                 :            :                 } else {
    2480                 :          0 :                         if (ep->dwc_ep.num == 0) {
    2481                 :          0 :                                 pcd->ep0state = EP0_STALL;
    2482                 :            :                         }
    2483                 :            : 
    2484                 :          0 :                         ep->stopped = 1;
    2485                 :          0 :                         dwc_otg_ep_set_stall(GET_CORE_IF(pcd), &ep->dwc_ep);
    2486                 :            :                 }
    2487                 :          0 :         } else if (value == 2) {
    2488                 :          0 :                 ep->dwc_ep.stall_clear_flag = 0;
    2489                 :          0 :         } else if (value == 3) {
    2490                 :          0 :                 ep->dwc_ep.stall_clear_flag = 1;
    2491                 :            :         }
    2492                 :            : 
    2493                 :          0 :         DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    2494                 :            : 
    2495                 :          0 :         return retval;
    2496                 :            : }
    2497                 :            : 
    2498                 :            : /**
    2499                 :            :  * This function initiates remote wakeup of the host from suspend state.
    2500                 :            :  */
    2501                 :          0 : void dwc_otg_pcd_rem_wkup_from_suspend(dwc_otg_pcd_t * pcd, int set)
    2502                 :            : {
    2503                 :          0 :         dctl_data_t dctl = { 0 };
    2504                 :          0 :         dwc_otg_core_if_t *core_if = GET_CORE_IF(pcd);
    2505                 :            :         dsts_data_t dsts;
    2506                 :            : 
    2507                 :          0 :         dsts.d32 = DWC_READ_REG32(&core_if->dev_if->dev_global_regs->dsts);
    2508                 :          0 :         if (!dsts.b.suspsts) {
    2509                 :          0 :                 DWC_WARN("Remote wakeup while is not in suspend state\n");
    2510                 :            :         }
    2511                 :            :         /* Check if DEVICE_REMOTE_WAKEUP feature enabled */
    2512                 :          0 :         if (pcd->remote_wakeup_enable) {
    2513                 :          0 :                 if (set) {
    2514                 :            : 
    2515                 :          0 :                         if (core_if->adp_enable) {
    2516                 :            :                                 gpwrdn_data_t gpwrdn;
    2517                 :            : 
    2518                 :          0 :                                 dwc_otg_adp_probe_stop(core_if);
    2519                 :            : 
    2520                 :            :                                 /* Mask SRP detected interrupt from Power Down Logic */
    2521                 :          0 :                                 gpwrdn.d32 = 0;
    2522                 :          0 :                                 gpwrdn.b.srp_det_msk = 1;
    2523                 :          0 :                                 DWC_MODIFY_REG32(&core_if->
    2524                 :            :                                                  core_global_regs->gpwrdn,
    2525                 :            :                                                  gpwrdn.d32, 0);
    2526                 :            : 
    2527                 :            :                                 /* Disable Power Down Logic */
    2528                 :          0 :                                 gpwrdn.d32 = 0;
    2529                 :          0 :                                 gpwrdn.b.pmuactv = 1;
    2530                 :          0 :                                 DWC_MODIFY_REG32(&core_if->
    2531                 :            :                                                  core_global_regs->gpwrdn,
    2532                 :            :                                                  gpwrdn.d32, 0);
    2533                 :            : 
    2534                 :            :                                 /*
    2535                 :            :                                  * Initialize the Core for Device mode.
    2536                 :            :                                  */
    2537                 :          0 :                                 core_if->op_state = B_PERIPHERAL;
    2538                 :          0 :                                 dwc_otg_core_init(core_if);
    2539                 :          0 :                                 dwc_otg_enable_global_interrupts(core_if);
    2540                 :            :                                 cil_pcd_start(core_if);
    2541                 :            : 
    2542                 :          0 :                                 dwc_otg_initiate_srp(core_if);
    2543                 :            :                         }
    2544                 :            : 
    2545                 :          0 :                         dctl.b.rmtwkupsig = 1;
    2546                 :          0 :                         DWC_MODIFY_REG32(&core_if->dev_if->dev_global_regs->
    2547                 :            :                                          dctl, 0, dctl.d32);
    2548                 :            :                         DWC_DEBUGPL(DBG_PCD, "Set Remote Wakeup\n");
    2549                 :            : 
    2550                 :          0 :                         dwc_mdelay(2);
    2551                 :          0 :                         DWC_MODIFY_REG32(&core_if->dev_if->dev_global_regs->
    2552                 :            :                                          dctl, dctl.d32, 0);
    2553                 :            :                         DWC_DEBUGPL(DBG_PCD, "Clear Remote Wakeup\n");
    2554                 :            :                 }
    2555                 :            :         } else {
    2556                 :            :                 DWC_DEBUGPL(DBG_PCD, "Remote Wakeup is disabled\n");
    2557                 :            :         }
    2558                 :          0 : }
    2559                 :            : 
    2560                 :            : #ifdef CONFIG_USB_DWC_OTG_LPM
    2561                 :            : /**
    2562                 :            :  * This function initiates remote wakeup of the host from L1 sleep state.
    2563                 :            :  */
    2564                 :            : void dwc_otg_pcd_rem_wkup_from_sleep(dwc_otg_pcd_t * pcd, int set)
    2565                 :            : {
    2566                 :            :         glpmcfg_data_t lpmcfg;
    2567                 :            :         dwc_otg_core_if_t *core_if = GET_CORE_IF(pcd);
    2568                 :            : 
    2569                 :            :         lpmcfg.d32 = DWC_READ_REG32(&core_if->core_global_regs->glpmcfg);
    2570                 :            : 
    2571                 :            :         /* Check if we are in L1 state */
    2572                 :            :         if (!lpmcfg.b.prt_sleep_sts) {
    2573                 :            :                 DWC_DEBUGPL(DBG_PCD, "Device is not in sleep state\n");
    2574                 :            :                 return;
    2575                 :            :         }
    2576                 :            : 
    2577                 :            :         /* Check if host allows remote wakeup */
    2578                 :            :         if (!lpmcfg.b.rem_wkup_en) {
    2579                 :            :                 DWC_DEBUGPL(DBG_PCD, "Host does not allow remote wakeup\n");
    2580                 :            :                 return;
    2581                 :            :         }
    2582                 :            : 
    2583                 :            :         /* Check if Resume OK */
    2584                 :            :         if (!lpmcfg.b.sleep_state_resumeok) {
    2585                 :            :                 DWC_DEBUGPL(DBG_PCD, "Sleep state resume is not OK\n");
    2586                 :            :                 return;
    2587                 :            :         }
    2588                 :            : 
    2589                 :            :         lpmcfg.d32 = DWC_READ_REG32(&core_if->core_global_regs->glpmcfg);
    2590                 :            :         lpmcfg.b.en_utmi_sleep = 0;
    2591                 :            :         lpmcfg.b.hird_thres &= (~(1 << 4));
    2592                 :            :         DWC_WRITE_REG32(&core_if->core_global_regs->glpmcfg, lpmcfg.d32);
    2593                 :            : 
    2594                 :            :         if (set) {
    2595                 :            :                 dctl_data_t dctl = {.d32 = 0 };
    2596                 :            :                 dctl.b.rmtwkupsig = 1;
    2597                 :            :                 /* Set RmtWkUpSig bit to start remote wakup signaling.
    2598                 :            :                  * Hardware will automatically clear this bit.
    2599                 :            :                  */
    2600                 :            :                 DWC_MODIFY_REG32(&core_if->dev_if->dev_global_regs->dctl,
    2601                 :            :                                  0, dctl.d32);
    2602                 :            :                 DWC_DEBUGPL(DBG_PCD, "Set Remote Wakeup\n");
    2603                 :            :         }
    2604                 :            : 
    2605                 :            : }
    2606                 :            : #endif
    2607                 :            : 
    2608                 :            : /**
    2609                 :            :  * Performs remote wakeup.
    2610                 :            :  */
    2611                 :          0 : void dwc_otg_pcd_remote_wakeup(dwc_otg_pcd_t * pcd, int set)
    2612                 :            : {
    2613                 :          0 :         dwc_otg_core_if_t *core_if = GET_CORE_IF(pcd);
    2614                 :            :         dwc_irqflags_t flags;
    2615                 :          0 :         if (dwc_otg_is_device_mode(core_if)) {
    2616                 :          0 :                 DWC_SPINLOCK_IRQSAVE(pcd->lock, &flags);
    2617                 :            : #ifdef CONFIG_USB_DWC_OTG_LPM
    2618                 :            :                 if (core_if->lx_state == DWC_OTG_L1) {
    2619                 :            :                         dwc_otg_pcd_rem_wkup_from_sleep(pcd, set);
    2620                 :            :                 } else {
    2621                 :            : #endif
    2622                 :          0 :                         dwc_otg_pcd_rem_wkup_from_suspend(pcd, set);
    2623                 :            : #ifdef CONFIG_USB_DWC_OTG_LPM
    2624                 :            :                 }
    2625                 :            : #endif
    2626                 :          0 :                 DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    2627                 :            :         }
    2628                 :          0 :         return;
    2629                 :            : }
    2630                 :            : 
    2631                 :          0 : void dwc_otg_pcd_disconnect_us(dwc_otg_pcd_t * pcd, int no_of_usecs)
    2632                 :            : {
    2633                 :          0 :         dwc_otg_core_if_t *core_if = GET_CORE_IF(pcd);
    2634                 :          0 :         dctl_data_t dctl = { 0 };
    2635                 :            : 
    2636                 :          0 :         if (dwc_otg_is_device_mode(core_if)) {
    2637                 :          0 :                 dctl.b.sftdiscon = 1;
    2638                 :          0 :                 DWC_PRINTF("Soft disconnect for %d useconds\n",no_of_usecs);
    2639                 :          0 :                 DWC_MODIFY_REG32(&core_if->dev_if->dev_global_regs->dctl, 0, dctl.d32);
    2640                 :          0 :                 dwc_udelay(no_of_usecs);
    2641                 :          0 :                 DWC_MODIFY_REG32(&core_if->dev_if->dev_global_regs->dctl, dctl.d32,0);
    2642                 :            : 
    2643                 :            :         } else{
    2644                 :          0 :                 DWC_PRINTF("NOT SUPPORTED IN HOST MODE\n");
    2645                 :            :         }
    2646                 :          0 :         return;
    2647                 :            : 
    2648                 :            : }
    2649                 :            : 
    2650                 :          0 : int dwc_otg_pcd_wakeup(dwc_otg_pcd_t * pcd)
    2651                 :            : {
    2652                 :            :         dsts_data_t dsts;
    2653                 :            :         gotgctl_data_t gotgctl;
    2654                 :            : 
    2655                 :            :         /*
    2656                 :            :          * This function starts the Protocol if no session is in progress. If
    2657                 :            :          * a session is already in progress, but the device is suspended,
    2658                 :            :          * remote wakeup signaling is started.
    2659                 :            :          */
    2660                 :            : 
    2661                 :            :         /* Check if valid session */
    2662                 :            :         gotgctl.d32 =
    2663                 :          0 :             DWC_READ_REG32(&(GET_CORE_IF(pcd)->core_global_regs->gotgctl));
    2664                 :          0 :         if (gotgctl.b.bsesvld) {
    2665                 :            :                 /* Check if suspend state */
    2666                 :            :                 dsts.d32 =
    2667                 :          0 :                     DWC_READ_REG32(&
    2668                 :          0 :                                    (GET_CORE_IF(pcd)->dev_if->
    2669                 :            :                                     dev_global_regs->dsts));
    2670                 :          0 :                 if (dsts.b.suspsts) {
    2671                 :          0 :                         dwc_otg_pcd_remote_wakeup(pcd, 1);
    2672                 :            :                 }
    2673                 :            :         } else {
    2674                 :          0 :                 dwc_otg_pcd_initiate_srp(pcd);
    2675                 :            :         }
    2676                 :            : 
    2677                 :          0 :         return 0;
    2678                 :            : 
    2679                 :            : }
    2680                 :            : 
    2681                 :            : /**
    2682                 :            :  * Start the SRP timer to detect when the SRP does not complete within
    2683                 :            :  * 6 seconds.
    2684                 :            :  *
    2685                 :            :  * @param pcd the pcd structure.
    2686                 :            :  */
    2687                 :          0 : void dwc_otg_pcd_initiate_srp(dwc_otg_pcd_t * pcd)
    2688                 :            : {
    2689                 :            :         dwc_irqflags_t flags;
    2690                 :          0 :         DWC_SPINLOCK_IRQSAVE(pcd->lock, &flags);
    2691                 :          0 :         dwc_otg_initiate_srp(GET_CORE_IF(pcd));
    2692                 :          0 :         DWC_SPINUNLOCK_IRQRESTORE(pcd->lock, flags);
    2693                 :          0 : }
    2694                 :            : 
    2695                 :          0 : int dwc_otg_pcd_get_frame_number(dwc_otg_pcd_t * pcd)
    2696                 :            : {
    2697                 :          0 :         return dwc_otg_get_frame_number(GET_CORE_IF(pcd));
    2698                 :            : }
    2699                 :            : 
    2700                 :          0 : int dwc_otg_pcd_is_lpm_enabled(dwc_otg_pcd_t * pcd)
    2701                 :            : {
    2702                 :          0 :         return GET_CORE_IF(pcd)->core_params->lpm_enable;
    2703                 :            : }
    2704                 :            : 
    2705                 :          0 : uint32_t get_b_hnp_enable(dwc_otg_pcd_t * pcd)
    2706                 :            : {
    2707                 :          0 :         return pcd->b_hnp_enable;
    2708                 :            : }
    2709                 :            : 
    2710                 :          0 : uint32_t get_a_hnp_support(dwc_otg_pcd_t * pcd)
    2711                 :            : {
    2712                 :          0 :         return pcd->a_hnp_support;
    2713                 :            : }
    2714                 :            : 
    2715                 :          0 : uint32_t get_a_alt_hnp_support(dwc_otg_pcd_t * pcd)
    2716                 :            : {
    2717                 :          0 :         return pcd->a_alt_hnp_support;
    2718                 :            : }
    2719                 :            : 
    2720                 :          0 : int dwc_otg_pcd_get_rmwkup_enable(dwc_otg_pcd_t * pcd)
    2721                 :            : {
    2722                 :          0 :         return pcd->remote_wakeup_enable;
    2723                 :            : }
    2724                 :            : 
    2725                 :            : #endif /* DWC_HOST_ONLY */
    

Generated by: LCOV version 1.14