开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > DSP编程 > 查看源码
c6x1x_edma_mcasp.c
资源名称：DSP-C6000-DM642DEMO.rar　[点击查看]
上传用户：dahaojd
上传日期：2008-01-29
资源大小：14357k
文件大小：38k
源码类别：

DSP编程

开发平台：

C/C++

c6x1x_edma_mcasp.c：源码内容
  1. /*
  2.  *  Copyright 2003 by Texas Instruments Incorporated.
  3.  *  All rights reserved. Property of Texas Instruments Incorporated.
  4.  *  Restricted rights to use, duplicate or disclose this code are
  5.  *  granted through contract.
  6.  *  
  7.  */
  8. /* "@(#) DDK 1.10.00.23 07-02-03 (ddk-b12)" */
  9. /* 
  10.  *  ======== c6x1x_edma_mcasp.c ========
  11.  * 
  12.  *  Generic McASP driver for the TMS320C6x1x series. Uses the EDMA.
  13.  */
  15. #include <std.h>
  16. #include <atm.h>
  17. #include <hwi.h>
  18. #include <que.h>
  20. #include <iom.h>
  22. #include <csl.h>
  23. #include <csl_mcasp.h>
  24. #include <csl_irq.h>
  25. #include <csl_edma.h>
  26. #include <csl_cache.h>
  27. #include <csl_chip.h>
  29. #include <c6x1x_edma_mcasp.h>
  31. /*
  32.  *  Macro to start serializer & state machine
  33.  *  if turned on, driver will start both transmit and receive serializer 
  34.  *  and state machine synchronously  
  35.  */
  36. #define STARTSERIALIZERSYNC     0
  38. /*
  39.  *  Macro to enable edma loop job interrupt
  40.  *  if turned on, each time edma loop job gets running, an ineterrupt will
  41.  *  be generated. This is only used for debug purpose.
  42.  */
  43. #define ENABLELOOPINTR          0 
  45. #if ENABLELOOPINTR
  46. #include <log.h>
  47. extern far LOG_Obj trace;
  48. #endif
  50. #define IRQEVTINPUT             5
  51. #define IRQEVTOUTPUT            6
  52. #define IRQEDMA                 8
  55. /* Maximum number of EDMA jobs linked at a time (Must be 2). */
  56. #define MAXLINKCNT 2
  58. /* Used as index since IOM mode is a bit mask and not an index */
  59. #define INPUT   0
  60. #define OUTPUT  1
  62. /* States for chanCleanUp() */
  63. #define SETFALSE 1
  64. #define FREETCC 2
  65. #define FREETABLE 3
  66. #define FREETABLEEX 4
  67. #define DELCHAN 5
  69. /* Macro to increment and return the indice that ranges over MAXLINKCNT */
  70. #define nextIndex(index) ((index) ^ 1)
  72. /* Number of ports available */
  73. #define NUMPORTS _MCASP_PORT_CNT 
  75. /* Number of channels per port (one input and one output channel) */
  76. #define NUMCHANS 2
  78. /* Structure containing channel specific variables */
  79. typedef struct ChanObj {
  80.     Uns inUse;                /* True if the channel is in use */
  81.     Int mode;                 /* Input or output channel */
  82.     struct PortObj *port;     /* Pointer to the port which owns this chan */
  83.     EDMA_Handle xferPram;     /* Handle to transfer PaRAM */
  84.     EDMA_Handle pramTbl[MAXLINKCNT]; /* Handles to link PaRAMs */
  85.     EDMA_Handle prevPramPtr;  /* Points to the PaRAM last used */
  86.     EDMA_Handle loophEdma;    /* Handle to the Loop job PaRAM */
  87.     IOM_Packet *flushPacket;  /* Holds the flushpacket (if any) */
  88.     IOM_Packet *abortPacket;  /* Holds the abortpacket (if any) */
  89.     IOM_Packet *packetList[MAXLINKCNT]; /* Holds linked  packets */
  90.     QUE_Obj packetQueue;      /* Holds submitted but not linked packets */
  91.     Int submitCount;          /* Number of submit calls pending */
  92.     Int writeIndex;           /* Index of next PaRAM to write to */
  93.     Int readIndex;            /* Index of next PaRAM to read from */
  94.     Int tcc;                  /* Channel transfer complete code */
  95.     IOM_TiomCallback cbFxn;   /* Called when I/O complete */
  96.     Ptr cbArg;                /* Argument to callback function */
  97. } ChanObj, *ChanHandle;
  99. /* Structure containing port specific variables */
  100. typedef struct PortObj {
  101.     Uns inUse;                /* True if the port is in use */
  102.     Int devId;                /* The device id passed to mdBindDev() */
  103.     Bool cacheCalls;          /* Submitted buffers are in cacheable memory */
  104.     Uint32 enableHclkg;       /* Holds enable Hclk variable */
  105.     Uint32 enableClkg;        /* Holds enable Clk variable */
  106.     Uint32 enableFsyncg;      /* Holds enable Fsync variable */
  107.     MCASP_Handle hMcasp;      /* CSL Device handle */
  108.     ChanObj chans[NUMCHANS];  /* The channels associated with the port */
  109.     Uns chanCreated;          /* One channel in this port has been Created */
  110.     C6X1X_EDMA_MCASP_TevtCallback evtCallback; /* event callback */
  111.     Uns evtMask;              /* registered events */
  112. } PortObj, *PortHandle;
  114. /* Declare the port and channel structures */
  115. static PortObj ports[NUMPORTS];
  117. /* Define EDMA Event Id's Array */
  118. static Uns eventIds[NUMPORTS][2] = {
  119.     { EDMA_CHA_AREVT0, EDMA_CHA_AXEVT0 },
  120. #if NUMPORTS >= 2
  121.     { EDMA_CHA_AREVT1, EDMA_CHA_AXEVT1 },
  122. #endif
  123. #if NUMPORTS == 3
  124.     { EDMA_CHA_AREVT2, EDMA_CHA_AXEVT2 }
  125. #endif
  126. };
  128. /*
  129.  * Forward declaration of the IOM interface functions. They are only
  130.  * exposed via the IOM function table to avoid namespace pollution.
  131.  */
  132. static Int mdBindDev(Ptr *devp, Int devid, Ptr devParams);
  133. static Int mdCreateChan(Ptr *chanp, Ptr devp, String name, Int mode,
  134.                         Ptr chanParams, IOM_TiomCallback cbFxn, Ptr cbArg);
  135. static Int mdDeleteChan(Ptr chanp);
  136. static Int mdSubmitChan(Ptr chanp, IOM_Packet *packet);
  137. static Int mdUnBindDev(Ptr devp);
  139. #if ENABLELOOPINTR
  140. static Void isrLoop(Int tcc);
  141. #endif
  143. /* Public IOM interface table */
  144. IOM_Fxns C6X1X_EDMA_MCASP_FXNS = {
  145.     &mdBindDev,
  146.     &mdUnBindDev,
  147.     IOM_CONTROLCHANNOTIMPL,
  148.     &mdCreateChan,
  149.     &mdDeleteChan,
  150.     &mdSubmitChan
  151. };
  153. /* Local function prototypes */
  154. static Void chanCleanUp(ChanHandle chan, Uns state);
  155. static Void isrCommon(ChanHandle chan);
  156. static Void isrInput(Int tcc);
  157. static Void isrOutput(Int tcc);
  158. static Void isrEvent(Int mode);
  159. static Void linkPacket(ChanHandle chan, IOM_Packet *packet);
  161. /* Local driver variables. */
  162. static Uint32 loopDstBuf;
  163. static Uint32 loopSrcBuf;
  165. #if ENABLELOOPINTR
  166. static Void isrLoop(Int tcc)
  167. {
  168.     LOG_printf(&trace, "LOOP=%d", tcc);
  169. }
  170. #endif
  172. /*
  173.  * ======== chanCleanUp ========
  174.  * Cleans up the channel resources.
  175.  */
  176. static Void chanCleanUp(ChanHandle chan, Uns state)
  177. {
  178.     switch(state) {
  179.     case DELCHAN:
  180.         /* Close the EDMA channel */
  181.         EDMA_close(chan->xferPram);
  183.         /* Disable transfer interrupts from the EDMA */
  184.         EDMA_intDisable(chan->tcc);
  185.         /* will fall through the next case */
  186.     case FREETABLEEX:
  187.         /* Free the EDMA link PaRAM tables */
  188.         EDMA_freeTableEx(MAXLINKCNT, chan->pramTbl);
  189.         /* will fall through the next case */
  190.     case FREETABLE:
  191.         /* Free the loop EDMA PaRAM table */
  192.         EDMA_freeTable(chan->loophEdma);
  193.         /* will fall through the next case */
  194.     case FREETCC:
  195.         /* Free the transfer complete code */
  196.         EDMA_intFree(chan->tcc);
  197.         /* will fall through the next case */
  198.     case SETFALSE:
  199.         /* Mark the channel as closed */
  200.         chan->inUse = FALSE;
  201.         break;
  202.     }
  203. }
  204. /*
  205.  * ======== isrCommon ========
  206.  * Shared ISR code between input and output. Processes a normal EDMA job.
  207.  */
  208. static Void isrCommon(ChanHandle chan)
  209. {
  210.     IOM_Packet *packet;
  211.     Int cnt;
  213.     /* Check to see if this is a completed async abort call */
  214.     if (chan->abortPacket) {
  215.         /* Discard all packets in transmission or queued up */
  216.         if (chan->submitCount > MAXLINKCNT) {
  217.             cnt = MAXLINKCNT;
  218.         }
  219.         else {
  220.             cnt = chan->submitCount;
  221.         }
  223.         while (cnt > 0) {
  224.             packet = chan->packetList[chan->readIndex];
  225.             packet->status = IOM_ABORTED;
  226.             (*chan->cbFxn)(chan->cbArg, packet);
  228.             chan->readIndex = nextIndex(chan->readIndex);
  229.             cnt--;
  230.         }
  232.         while (!QUE_empty(&chan->packetQueue)) {
  233.             packet = QUE_dequeue(&chan->packetQueue);
  234.             packet->status = IOM_ABORTED;
  235.             (*chan->cbFxn)(chan->cbArg, packet);
  236.         }
  238.         /* Reset the driver channel state */
  239.         chan->writeIndex = 0;
  240.         chan->readIndex = 0;
  241.         chan->submitCount = 0;
  243.         chan->abortPacket->status = IOM_COMPLETED;
  244.         (*chan->cbFxn)(chan->cbArg, chan->abortPacket);
  245.         chan->abortPacket = NULL;
  246.         return;
  247.     }
  249.     /* Fetch the completed packet */
  250.     packet = chan->packetList[chan->readIndex];
  252.     chan->readIndex = nextIndex(chan->readIndex);
  254.     /* Mark the packet as completed */
  255.     packet->status = IOM_COMPLETED;
  257.     /* Call the callback function */
  258.     (*chan->cbFxn)(chan->cbArg, packet);
  260.     chan->submitCount--;
  262.     /*
  263.      * See if there are any unlinked packets in the packetQueue
  264.      * and if so link them.
  265.      */
  266.     if (chan->submitCount >= MAXLINKCNT) {
  267.         packet = QUE_dequeue(&chan->packetQueue);
  268.         linkPacket(chan, packet);
  269.     }
  270. }
  272. /*
  273.  * ======== isrInput ========
  274.  * The input isr called from the EDMA dispatcher every time an input
  275.  * EDMA job completes.
  276.  */
  277. static Void isrInput(Int tcc)
  278. {
  279.     ChanHandle chan;
  280.     Int portNbr;
  282.     /* Check which port was responsible for the interrupt */
  283.     for (portNbr = 0; portNbr < NUMPORTS; portNbr++) {
  284.         chan = &ports[portNbr].chans[INPUT];
  286.         if (chan->tcc == tcc && chan->inUse) {
  288.             if (EDMA_RGETH(chan->xferPram, DST) == (Uint32) &loopDstBuf &&
  289.                 chan->submitCount > 1 && !chan->abortPacket) {
  290.                 /*
  291.                  * An emulation halt has occured with more than 1 job
  292.                  * submitted. Link the currently executing job (the Loop job)
  293.                  * to the first of the linked jobs which hadn't been called
  294.                  * back. This way we still have the same number of submitted
  295.                  * jobs after the execution continues as we had before the
  296.                  * emulation halt (breakpoint) occured (this preserves double
  297.                  * buffering if used).
  298.                  */
  299.                 EDMA_disableChannel(chan->xferPram);
  300.                 EDMA_link(chan->xferPram, chan->pramTbl[chan->readIndex]);
  301.                 EDMA_enableChannel(chan->xferPram);
  302.             }
  303.             else {
  304.                 /* Call the common ISR code for a finished normal EDMA job */
  305.                 isrCommon(chan);
  306.             }
  307.         }
  308.     }
  309. }
  311. /*
  312.  * ======== isrOutput ========
  313.  * The output isr called from the EDMA dispatcher every time an output
  314.  * EDMA job completes.
  315.  */
  316. static Void isrOutput(Int tcc)
  317. {
  318.     ChanHandle chan;
  319.     Int portNbr;
  321.     /* Check which port was responsible for the interrupt */
  322.     for (portNbr = 0; portNbr < NUMPORTS; portNbr++) {
  323.         chan = &ports[portNbr].chans[OUTPUT];
  325.         if (chan->tcc == tcc && chan->inUse) {
  327.             if (EDMA_RGETH(chan->xferPram, SRC) == (Uint32)&loopSrcBuf &&
  328.                 chan->submitCount > 1 && !chan->abortPacket) {
  329.                 /*
  330.                  * An emulation halt has occured with more than 1 job
  331.                  * submitted. Link the currently executing job (the Loop job)
  332.                  * to the first of the linked jobs which hadn't been called
  333.                  * back. This way we still have the same number of submitted
  334.                  * jobs after the execution continues as we had before the
  335.                  * emulation halt (breakpoint) occured (this preserves double
  336.                  * buffering if used).
  337.                  */
  338.                 EDMA_disableChannel(chan->xferPram);
  339.                 EDMA_link(chan->xferPram, chan->pramTbl[chan->readIndex]);
  340.                 EDMA_enableChannel(chan->xferPram);
  341.             }
  342.             else {
  343.                 /* Call the common ISR code for a finished normal EDMA job */
  344.                 isrCommon(chan);
  346.                 /* Check to see if an async flush has completed */
  347.                 if (chan->submitCount == 0 && chan->flushPacket) {
  348.                     chan->flushPacket->status = IOM_COMPLETED;
  349.                     (*chan->cbFxn)(chan->cbArg,chan->flushPacket);
  350.                     chan->flushPacket = NULL;
  351.                 }
  352.             }
  353.         }
  354.     }
  355. }
  357. /*
  358.  * ======== isrEvent ========
  359.  * The event isr called when an McASP input/output event happens
  360.  * This is used for exception event handling asserted by McASP. Normal data
  361.  * hanlding is done by EDMA. 
  362.  */
  363. static Void isrEvent(Int mode)
  364. {
  365.     MCASP_Handle hMcasp;
  366.     Uns portNbr;
  367.     Uns events;
  368.     Uns eventReturn;
  369.     
  370.     /* Check which port was responsible for the interrupt */
  371.     for (portNbr = 0; portNbr < NUMPORTS; portNbr++) {
  372.         if (ports[portNbr].inUse) {
  373.             hMcasp = ports[portNbr].hMcasp;
  374.             events = 0;
  375.             if (mode == INPUT) {          
  376.                 if (MCASP_FGETH(hMcasp, RSTAT, ROVRN)) {
  377.                     MCASP_FSETSH(hMcasp, RSTAT, ROVRN, YES);
  378.                     events |= C6X1X_EDMA_MCASP_EVT_ROVRN;
  379.                 } 
  380.                 if (MCASP_FGETH(hMcasp, RSTAT, RCKFAIL)) {
  381.                     MCASP_FSETSH(hMcasp, RSTAT, RCKFAIL, YES);
  382.                     events |= C6X1X_EDMA_MCASP_EVT_RCKFAIL;
  383.                 }
  384.                 if (MCASP_FGETH(hMcasp, RSTAT, RSYNCERR)) {
  385.                     MCASP_FSETSH(hMcasp, RSTAT, RSYNCERR, YES);
  386.                     events |= C6X1X_EDMA_MCASP_EVT_RSYNCERR;
  387.                 }   
  388.                 if (MCASP_FGETH(hMcasp, RSTAT, RDMAERR)) {
  389.                     MCASP_FSETH(hMcasp, RSTAT, RDMAERR, 1);
  390.                     events |= C6X1X_EDMA_MCASP_EVT_RDMAERR;
  391.                 }   
  392.                 /* Clear not registered events here */
  393.                 MCASP_RSETH(hMcasp, RSTAT, 0xFFFFFFFF);
  394.             } 
  395.             else {
  396.                 if (MCASP_FGETH(hMcasp, XSTAT, XUNDRN)) {
  397.                     MCASP_FSETSH(hMcasp, XSTAT, XUNDRN, YES);
  398.                     events |= C6X1X_EDMA_MCASP_EVT_XUNDRN;
  399.                 } 
  400.                 if (MCASP_FGETH(hMcasp, XSTAT, XCKFAIL)) {
  401.                     MCASP_FSETSH(hMcasp, XSTAT, XCKFAIL, YES);
  402.                     events |= C6X1X_EDMA_MCASP_EVT_XCKFAIL;
  403.                 }
  404.                 if (MCASP_FGETH(hMcasp, XSTAT, XSYNCERR)) {
  405.                     MCASP_FSETSH(hMcasp, XSTAT, XSYNCERR, YES);
  406.                     events |= C6X1X_EDMA_MCASP_EVT_XSYNCERR;
  407.                 }   
  408.                 if (MCASP_FGETH(hMcasp, XSTAT, XDMAERR)) {
  409.                     MCASP_FSETH(hMcasp, XSTAT, XDMAERR, 1);
  410.                     events |= C6X1X_EDMA_MCASP_EVT_XDMAERR;
  411.                 }   
  412.                 /* Clear not registered events here */
  413.                 MCASP_RSETH(hMcasp, XSTAT, 0xFFFFFFFF);
  414.             }
  415.             eventReturn = ports[portNbr].evtMask & events;
  416.  
  417.             if (eventReturn) {
  418.                 (*ports[portNbr].evtCallback)(eventReturn, portNbr);
  419.             } 
  420.         }   
  421.     }    
  422. }
  424. /*
  425.  * ======== linkPacket ========
  426.  * Links a packet with the EDMA. When called by mdSubmitChan() it is called
  427.  * with all interrupts disabled, but when called by an ISR only the EDMA IRQ
  428.  * is disabled.
  429.  */
  430. static Void linkPacket(ChanHandle chan, IOM_Packet *packet)
  431. {
  432.     EDMA_Handle pramPtr;
  433.     Uns edmaCnt;
  435.     /* Store the packet in the packetList */
  436.     chan->packetList[chan->writeIndex] = packet;
  438.     /* Set up pointer to link PaRAM to write submit job info to */
  439.     pramPtr = chan->pramTbl[chan->writeIndex];
  440.     chan->writeIndex = nextIndex(chan->writeIndex);
  442.     /* Load the buffer pointer into the EDMA */
  443.     if (chan->mode == INPUT) {
  444.         EDMA_RSETH(pramPtr, DST, (Uint32) packet->addr);
  445.     }
  446.     else {
  447.         EDMA_RSETH(pramPtr, SRC, (Uint32) packet->addr);
  448.     }
  450.     /*
  451.      * Load the transfer count (in samples) into the EDMA. Use the ESIZE
  452.      * field of the EDMA job to calculate number of samples.
  453.      */
  454.     edmaCnt = (Uint32)packet->size >> (2 - EDMA_FGETH(pramPtr, OPT, ESIZE));
  455.     EDMA_FSETH(pramPtr, CNT, FRMCNT, (edmaCnt / 
  456.             EDMA_FGETH(pramPtr, CNT, ELECNT) - 1)); 
  458.     /*
  459.      * Link to loop EDMA job upon termination. This way we won't
  460.      * loose the frame sync if the channel is starved.
  461.      */
  462.     EDMA_link(pramPtr, chan->loophEdma);
  464.     /* Disable the EDMA channel to make sure current job doesn't complete */
  465.     EDMA_disableChannel(chan->xferPram);
  467.     /*
  468.      * Link the currently executing job to the new job. This can be
  469.      * either the loop EDMA job or a real data EDMA job.
  470.      */
  471.     EDMA_link(chan->xferPram, pramPtr);
  473.     if (chan->submitCount > 0) {
  474.         /*
  475.          * We need to link the parameter space corresponding to the running
  476.          * job so that if a breakpoint occurs, we know how to recover.
  477.          */
  478.         EDMA_link(chan->prevPramPtr, pramPtr);
  479.     }
  481.     /* Reenable the EDMA channel */
  482.     EDMA_enableChannel(chan->xferPram);
  484.     /* Save the new job for the loop above for next time */
  485.     chan->prevPramPtr = pramPtr;
  486. }
  488. /*
  489.  * ======== mdBindDev ========
  490.  * This function allocates and configures the McASP port specified by devId.
  491.  */
  492. static Int mdBindDev(Ptr *devp, Int devid, Ptr devParams)
  493. {
  494.     Uns old;
  495.     Int inIrqId;
  496.     int outIrqId;
  497.     int irqId;
  498.     PortHandle port;
  499.     HWI_Attrs hwiAttrs;
  500.     C6X1X_EDMA_MCASP_DevParams *params =
  501.         (C6X1X_EDMA_MCASP_DevParams *) devParams;
  503.     /* This driver must receive a valid devparams */
  504.     if (params == NULL) {
  505.         return (IOM_EBADARGS);
  506.     }
  508.     /* Check the version number */
  509.     if (params->versionId != C6X1X_EDMA_MCASP_VERSION_1){
  510.         /* Unsupported version */
  511.         return(IOM_EBADARGS);
  512.     }
  514.     /* Get the device parameters of the specified port */
  515.     port = &ports[devid];
  517.     /* Mark the port as in use */
  518.     old = ATM_setu(&(port->inUse), TRUE);
  520.     /* Check if the port was already bound */
  521.     if (old) {
  522.         return (IOM_EALLOC);
  523.     }
  525.     /* Map the supplied IRQ to the EDMA event */
  526.     if (params->irqId > 0 ) {
  527.         irqId = params->irqId;
  528.     }
  529.     else {
  530.         irqId = IRQEDMA;
  531.     }
  532.     IRQ_map(IRQ_EVT_EDMAINT, irqId);
  534.     hwiAttrs.intrMask = params->edmaIntrMask;
  535.     hwiAttrs.ccMask = IRQ_CCMASK_NONE; /* the default value */
  536.     hwiAttrs.arg = NULL;
  538.     /* Plug the EDMA dispatcher into the HWI dispatcher */
  539.     HWI_dispatchPlug(irqId, (Fxn)EDMA_intDispatcher, -1, &hwiAttrs);
  540.    
  541.     /* Set the McASP high frequency sample rate generator */
  542.     /* Set the McASP sample rate generator */
  543.     /* Set the McASP frame sync generator */
  544.     port->enableHclkg = params->enableHclkg;
  545.     port->enableClkg = params->enableClkg;
  546.     port->enableFsyncg = params->enableFsyncg;
  548.     /* True if buffers are in external memory */
  549.     port->cacheCalls = params->cacheCalls;
  551.     /* Store the devid */
  552.     port->devId = devid;
  554.     /* No channel create yet */
  555.     port->chanCreated = 0;
  557.     /* Open and reset the McASP */
  558.     port->hMcasp = MCASP_open(devid, MCASP_OPEN_RESET);
  560.     if (port->hMcasp == INV) {
  561.         return (IOM_EALLOC);
  562.     }
  564.     /* Configure the McASP with the supplied configuration */
  565.     MCASP_config(port->hMcasp, params->mcaspCfgPtr);
  567.     if (params->evtCallback != NULL) {
  568.         /* register the events */
  569.         port->evtCallback = params->evtCallback->evtFxn;
  570.         port->evtMask = params->evtCallback->evtMask;
  571.  
  572.         if (params->inEvtIrqId > 0) {
  573.             inIrqId = params->inEvtIrqId;
  574.         }
  575.         else {
  576.             inIrqId = IRQEVTINPUT;
  577.         } 
  579.         if (params->outEvtIrqId > 0) {
  580.             outIrqId = params->outEvtIrqId;
  581.         }
  582.         else {
  583.             outIrqId = IRQEVTOUTPUT;
  584.         } 
  586.         IRQ_map(MCASP_getXmtEventId(port->hMcasp), outIrqId);
  587.         IRQ_map(MCASP_getRcvEventId(port->hMcasp), inIrqId); 
  589.         hwiAttrs.intrMask = params->inEvtIntrMask;
  590.         hwiAttrs.ccMask = IRQ_CCMASK_NONE; /* the default value */
  591.         hwiAttrs.arg = INPUT;
  592.         HWI_dispatchPlug(inIrqId, (Fxn)isrEvent, -1, &hwiAttrs);
  594.         hwiAttrs.intrMask = params->outEvtIntrMask;
  595.         hwiAttrs.ccMask = IRQ_CCMASK_NONE; /* the default value */
  596.         hwiAttrs.arg = OUTPUT;
  597.         HWI_dispatchPlug(outIrqId, (Fxn)isrEvent, -1, &hwiAttrs);
  598.     } 
  599.     else {
  600.         port->evtCallback = NULL;
  601.     }
  603.     /* set 0xe for debug, real value should be 0 */
  604.     loopSrcBuf = 0;
  605.     loopDstBuf = 0; 
  607.     /* Return the device handle and a status code for success */
  608.     *devp = port;
  609.     return (IOM_COMPLETED);
  610. }
  612. /*
  613.  * ======== mdCreateChan ========
  614.  * This function creates and configures a device channel.
  615.  */
  616. static Int mdCreateChan(Ptr *chanp, Ptr devp, String name, Int mode,
  617.                         Ptr chanParams, IOM_TiomCallback cbFxn, Ptr cbArg)
  618. {
  619.     PortHandle port = (PortHandle) devp;
  620.     C6X1X_EDMA_MCASP_ChanParams *params =
  621.         (C6X1X_EDMA_MCASP_ChanParams *) chanParams;
  622.     ChanHandle chan;
  623.     Uns old;
  624.     Uns esize;
  625.     Uns cnt;
  626.     Uns fs;
  627.     Uns elerld;
  628.     Uns mcaspAddr;
  629.     Int edmaChanEvent;
  630.     Int i;
  631. #if ENABLELOOPINTR
  632.     Int loopTcc;
  633. #endif
  635.     /*
  636.      * Configuration structure for the loop EDMA job. If the McASP
  637.      * is left to free running, this loop job is running when there is
  638.      * no data to transfer. This is useful if the McASP is externally
  639.      * clocked.  If the driver is starved or if an emulation halt
  640.      * (breakpoint) occurs, the frame sync will still be correct when
  641.      * the driver continues transmitting data.
  642.      */
  643.     EDMA_Config loopEdmaCfg = {
  644.         EDMA_FMKS(OPT, PRI, HIGH)           |
  645.         EDMA_FMKS(OPT, ESIZE, 32BIT)        |
  646.         EDMA_FMKS(OPT, 2DS, NO)             |
  647.         EDMA_FMKS(OPT, SUM, NONE)           |
  648.         EDMA_FMKS(OPT, 2DD, NO)             |
  649.         EDMA_FMKS(OPT, DUM, NONE)           |
  650.         EDMA_FMKS(OPT, TCINT, NO)           |
  651.         EDMA_FMKS(OPT, TCC, DEFAULT)        |
  652.         EDMA_FMKS(OPT, LINK, YES)           |
  653.         EDMA_FMKS(OPT, FS, NO),
  655.         EDMA_FMK (SRC, SRC, NULL),
  657.         EDMA_FMK (CNT, FRMCNT, 0)           |
  658.         EDMA_FMK (CNT, ELECNT, 0),
  660.         EDMA_FMKS(IDX, FRMIDX, OF(0))       |
  661.         EDMA_FMKS(IDX, ELEIDX, OF(0)),
  663.         EDMA_FMK (DST, DST, NULL),
  665.         EDMA_FMK (RLD, ELERLD, 0)           |
  666.         EDMA_FMK (RLD, LINK, NULL)
  667.     };
  670.     /* This driver needs a valid channel parameter structure passed */
  671.     if (params == NULL) {
  672.         return (IOM_EBADARGS);
  673.     }
  675.     /* Use own indexes since IOM mode is a bit mask and not an index */
  676.     if (mode == IOM_INPUT) {
  677.         chan = &port->chans[INPUT];
  678.         chan->mode = INPUT;
  679.     }
  680.     else {
  681.         chan = &port->chans[OUTPUT];
  682.         chan->mode = OUTPUT;
  683.     }
  685.     /* Mark the channel as used */
  686.     old = ATM_setu(&(chan->inUse), TRUE);
  688.     /* Make sure the channel wasn't already created */
  689.     if (old) {
  690.         return (IOM_EALLOC);
  691.     }
  693.     /* Initialise the channel structure */
  694.     chan->cbFxn = cbFxn;
  695.     chan->cbArg = cbArg;
  696.     chan->port = port;
  697.     chan->writeIndex = 0;
  698.     chan->readIndex = 0;
  699.     chan->submitCount = 0;
  700.     chan->flushPacket = NULL;
  701.     chan->abortPacket = NULL;
  703.     /* Initialize the packet queue */
  704.     QUE_new(&chan->packetQueue);
  706.     /*
  707.      * Set the number of elements (corresponding to number of McASP TDM
  708.      * channels) used in the Loop job to preserve the frame sync.
  709.      * FRMCNT should be (num of TDM slots - 1);
  710.      */
  711.     cnt = params->tdmChans - 1;
  712.     EDMA_FSETA(&loopEdmaCfg.cnt, CNT, FRMCNT, cnt);
  713.     EDMA_FSETA(&loopEdmaCfg.cnt, CNT, ELECNT, params->edmaCfgPtr->cnt);
  715.     /* Use the same sample size in the Loop job as in normal jobs */
  716.     esize = EDMA_FGETA(&params->edmaCfgPtr->opt, OPT, ESIZE);
  717.     EDMA_FSETA(&loopEdmaCfg.opt, OPT, ESIZE, esize);
  719.     /* Use  the same FS info as in the normal job */
  720.     fs = EDMA_FGETA(&params->edmaCfgPtr->opt, OPT, FS); 
  721.     EDMA_FSETA(&loopEdmaCfg.opt, OPT, FS, fs);
  723.     /* Use  the same ELERLD info as in the normal job */
  724.     elerld = EDMA_FGETA(&params->edmaCfgPtr->rld, RLD, ELERLD); 
  725.     EDMA_FSETA(&loopEdmaCfg.rld, RLD, ELERLD, elerld); 
  727.     /* Allocate a TCC for the EDMA */
  728.     chan->tcc = EDMA_intAlloc(-1);
  729.     /* If tcc > 15 we abort. */
  730.     if (chan->tcc == -1 || chan->tcc > 15) {
  731.         chanCleanUp(chan, SETFALSE);
  732.         return (IOM_EALLOC);
  733.     }
  735. #if ENABLELOOPINTR
  736.     loopTcc = EDMA_intAlloc(-1);
  737.     /* If tcc > 15 we abort. */
  738.     if (loopTcc == -1 || loopTcc > 15) {
  739.         EDMA_intFree(loopTcc);
  740.         chanCleanUp(chan, FREETCC);
  741.         return (IOM_EALLOC);
  742.     }
  743. #endif
  745.     /* Allocate an EDMA PaRAM for the Loop EDMA job. */
  746.     chan->loophEdma = EDMA_allocTable(-1);
  748.     if (chan->loophEdma == EDMA_HINV) {
  749.         chanCleanUp(chan, FREETCC);
  750.         return (IOM_EALLOC);
  751.     }
  753.     /*
  754.      * Allocate EDMA PaRAM link area based on max number of
  755.      * submits possible.
  756.      */
  757.     if (EDMA_allocTableEx(MAXLINKCNT, chan->pramTbl) != MAXLINKCNT) {
  758.         chanCleanUp(chan, FREETABLE);
  759.         return (IOM_EALLOC);
  760.     }
  762.     /* workaround for big endian problem in McASP */
  763.     if (chan->mode == INPUT) {
  764.         mcaspAddr = MCASP_getRbufAddr(port->hMcasp);
  765.     }
  766.     else {
  767.         mcaspAddr = MCASP_getXbufAddr(port->hMcasp);
  768.     }
  770. #ifdef _BIG_ENDIAN
  771.     if (esize == EDMA_OPT_ESIZE_8BIT) {
  772.         mcaspAddr += 3;
  773.     }
  774.     else if (esize == EDMA_OPT_ESIZE_16BIT) {
  775.         mcaspAddr += 2;
  776.     }
  777. #endif
  779.     if (chan->mode == INPUT) {
  780.         
  781.         /* Put input specific parameters in the Loop EDMA config */
  782.         EDMA_RSETA(&loopEdmaCfg.src, SRC, mcaspAddr);
  783.         EDMA_RSETA(&loopEdmaCfg.dst, DST, (Uint32) &loopDstBuf);
  785.         EDMA_RSETA(&params->edmaCfgPtr->src, SRC, mcaspAddr);
  786.         /* Register our isrInput with the EDMA dispatcher */
  787.         EDMA_intHook(chan->tcc, &isrInput);
  788.     }
  789.     else {     
  790.         
  791.         /* Put output specific parameters in the Loop EDMA config */
  792.         EDMA_RSETA(&loopEdmaCfg.src, SRC, (Uint32) &loopSrcBuf);
  793.         EDMA_RSETA(&loopEdmaCfg.dst, DST, mcaspAddr);
  795.         EDMA_RSETA(&params->edmaCfgPtr->dst, DST, mcaspAddr);
  796.         /* Register our isrOutput with the EDMA dispatcher */
  797.         EDMA_intHook(chan->tcc, &isrOutput);
  798.     }
  800.     /* Open theEDMA Channel */
  801. #if (CHIP_DM642)
  802.     edmaChanEvent = eventIds[port->devId][chan->mode]; 
  803. #else
  804.     edmaChanEvent = EDMA_map(eventIds[port->devId][chan->mode], 
  805.             params->edmaChan); 
  806. #endif
  807.     chan->xferPram = EDMA_open(edmaChanEvent, EDMA_OPEN_RESET);
  809.     if (chan->xferPram == EDMA_HINV) {
  810.         chanCleanUp(chan, FREETABLEEX);
  811.         return (IOM_EALLOC);
  812.     }
  814.     /* Program the data EDMA job with the TCC */
  815.     EDMA_FSETA(&params->edmaCfgPtr->opt, OPT, TCC, chan->tcc);
  817. #if ENABLELOOPINTR
  818.     EDMA_intHook(loopTcc, &isrLoop);
  819.     EDMA_FSETA(&loopEdmaCfg.opt, OPT, TCINT, EDMA_OPT_TCINT_YES);
  820.     EDMA_FSETA(&loopEdmaCfg.opt, OPT, TCC, loopTcc);
  821. #endif
  823.     /* Program the link PaRAMs with the config struct */
  824.     for (i=0; i < MAXLINKCNT; i++) {
  825.         EDMA_config(chan->pramTbl[i], params->edmaCfgPtr);
  826.     }
  828.     /* Program the Loop EDMA job with its config struct */
  829.     EDMA_config(chan->loophEdma, &loopEdmaCfg);
  831.     /*
  832.      * Link the Loop EDMA job to itself to make it run
  833.      * continuously when there is no data to transmit.
  834.      */
  835.     EDMA_link(chan->loophEdma, chan->loophEdma);
  837.     /* Configure the EDMA channel to start with the Loop EDMA job */
  838.     EDMA_config(chan->xferPram, &loopEdmaCfg);
  839.     EDMA_link(chan->xferPram, chan->loophEdma);
  841.     /* Transfer complete is edge triggered, so clear before enabling */
  842.     EDMA_intClear(chan->tcc);
  843.     EDMA_intEnable(chan->tcc);
  845. #if ENABLELOOPINTR
  846.     EDMA_intClear(loopTcc);
  847.     EDMA_intEnable(loopTcc);
  848. #endif
  850.     /* Enable the EDMA interrupt */
  851.     IRQ_enable(IRQ_EVT_EDMAINT);
  853.     EDMA_enableChannel(chan->xferPram);
  855.     /* Start the McASP */
  856.     if (chan->mode == INPUT) {
  857.         old = ATM_setu(&(port->chanCreated), TRUE);
  858.         
  859.         /* 
  860.          * clock generator is divided from high frequency clock, so start high
  861.          * freq clock generator first 
  862.          */
  863.         if (port->enableHclkg == C6X1X_EDMA_MCASP_RCV) {
  864.             MCASP_enableHclk(port->hMcasp, MCASP_RCV); 
  865.             while(!MCASP_FGETH(port->hMcasp, GBLCTL, RHCLKRST));
  866.         }
  867.         else if ((port->enableHclkg == C6X1X_EDMA_MCASP_RCVXMT) && (old)) {
  868.             MCASP_enableHclk(port->hMcasp, MCASP_RCVXMT); 
  869.             while(!(MCASP_FGETH(port->hMcasp, GBLCTL, RHCLKRST) & 
  870.                     MCASP_FGETH(port->hMcasp, GBLCTL, XHCLKRST)));
  871.         }
  873.         if (port->enableClkg == C6X1X_EDMA_MCASP_RCV) {
  874.             MCASP_enableClk(port->hMcasp, MCASP_RCV); 
  875.             while(!MCASP_FGETH(port->hMcasp, GBLCTL, RCLKRST)); 
  876.         } 
  877.         else if ((port->enableClkg == C6X1X_EDMA_MCASP_RCVXMT) && (old)) {
  878.             MCASP_enableClk(port->hMcasp, MCASP_RCVXMT); 
  879.             while(!( MCASP_FGETH(port->hMcasp, GBLCTL, RCLKRST) & 
  880.                 MCASP_FGETH(port->hMcasp, GBLCTL, XCLKRST)));
  881.         } 
  883. #if STARTSERIALIZERSYNC
  884.         if (old) {
  885.             MCASP_enableSers(port->hMcasp, MCASP_RCVXMT);
  886.             while (!(MCASP_FGETH(port->hMcasp, GBLCTL, RSRCLR) &
  887.                     MCASP_FGETH(port->hMcasp, GBLCTL, XSRCLR)));
  889.             while (MCASP_xdata(port->hMcasp));
  891.             MCASP_enableSm(port->hMcasp, MCASP_RCVXMT);
  892.             while (!(MCASP_FGETH(port->hMcasp, GBLCTL, RSMRST) &
  893.                     MCASP_FGETH(port->hMcasp, GBLCTL, XSMRST)));     
  894.         }
  895. #else
  896.         MCASP_enableSers(port->hMcasp, MCASP_RCV);
  897.         while (!MCASP_FGETH(port->hMcasp, GBLCTL, RSRCLR));
  899.         MCASP_enableSm(port->hMcasp, MCASP_RCV);
  900.         while (!MCASP_FGETH(port->hMcasp, GBLCTL, RSMRST));     
  901. #endif
  903.         if (port->enableFsyncg == C6X1X_EDMA_MCASP_RCV) {
  904.               MCASP_enableFsync(port->hMcasp, MCASP_RCV);
  905.               while(!MCASP_FGETH(port->hMcasp, GBLCTL, RFRST));    
  906.         }
  907.         else if ((port->enableFsyncg == C6X1X_EDMA_MCASP_RCVXMT) && (old)) {
  908.             MCASP_enableFsync(port->hMcasp, MCASP_RCVXMT);
  909.             while(!(MCASP_FGETH(port->hMcasp, GBLCTL, RFRST) & 
  910.                     MCASP_FGETH(port->hMcasp, GBLCTL, XFRST)) );       
  911.         } 
  912.     }
  913.     else {
  914.         old = ATM_setu(&(port->chanCreated), TRUE);
  916.         /* 
  917.          * clock generator is divided from high frequency clock, so start high
  918.          * freq clock generator first 
  919.          */
  920.         if (port->enableHclkg == C6X1X_EDMA_MCASP_XMT) {
  921.             MCASP_enableHclk(port->hMcasp, MCASP_XMT); 
  922.             while(!MCASP_FGETH(port->hMcasp, GBLCTL, XHCLKRST));
  924.         }
  925.         else if ((port->enableHclkg  == C6X1X_EDMA_MCASP_RCVXMT) && (old)) {
  926.             MCASP_enableHclk(port->hMcasp, MCASP_RCVXMT); 
  927.             while(!( MCASP_FGETH(port->hMcasp, GBLCTL, RHCLKRST) & 
  928.                     MCASP_FGETH(port->hMcasp, GBLCTL, XHCLKRST)));
  929.         }
  931.         if (port->enableClkg == C6X1X_EDMA_MCASP_XMT) {
  932.             MCASP_enableClk(port->hMcasp, MCASP_XMT); 
  933.             while(!MCASP_FGETH(port->hMcasp, GBLCTL, XCLKRST));
  934.         }
  935.         else if ((port->enableClkg == C6X1X_EDMA_MCASP_RCVXMT) && (old)) {
  936.             MCASP_enableClk(port->hMcasp, MCASP_RCVXMT); 
  937.             while(!( MCASP_FGETH(port->hMcasp, GBLCTL, RCLKRST) & 
  938.                     MCASP_FGETH(port->hMcasp, GBLCTL, XCLKRST)));
  939.         }
  942. #if STARTSERIALIZERSYNC
  943.         if (old) {
  944.             MCASP_enableSers(port->hMcasp, MCASP_RCVXMT);
  945.             while (!(MCASP_FGETH(port->hMcasp, GBLCTL, XSRCLR) &
  946.                     MCASP_FGETH(port->hMcasp, GBLCTL, RSRCLR)));
  948.             while (MCASP_xdata(port->hMcasp));
  950.             MCASP_enableSm(port->hMcasp, MCASP_RCVXMT);
  951.             while (!(MCASP_FGETH(port->hMcasp, GBLCTL, XSMRST) &
  952.                     MCASP_FGETH(port->hMcasp, GBLCTL, RSMRST)));     
  953.         }
  954. #else
  955.         MCASP_enableSers(port->hMcasp, MCASP_XMT);
  956.         while (!(MCASP_FGETH(port->hMcasp, GBLCTL, XSRCLR)));
  958.         while (MCASP_xdata(port->hMcasp));
  960.         MCASP_enableSm(port->hMcasp, MCASP_XMT);
  961.         while (!(MCASP_FGETH(port->hMcasp, GBLCTL, XSMRST)));     
  962. #endif
  964.         if (port->enableFsyncg == C6X1X_EDMA_MCASP_XMT) {
  965.             MCASP_enableFsync(port->hMcasp, MCASP_XMT);
  966.             while(!MCASP_FGETH(port->hMcasp,GBLCTL, XFRST));       
  967.         }
  968.         else if ((port->enableFsyncg == C6X1X_EDMA_MCASP_RCVXMT) && (old)) {
  969.             MCASP_enableFsync(port->hMcasp, MCASP_RCVXMT);
  970.             while(!(MCASP_FGETH(port->hMcasp,GBLCTL, RFRST) & 
  971.                     MCASP_FGETH(port->hMcasp,GBLCTL, XFRST)) );       
  972.         } 
  973.     } 
  975.     /* enable McASP event interrupt if registered */
  976.     /* Clear CKFAIL error before enable interrupt */
  977.     if (chan->mode == INPUT) { 
  978.         if (port->evtCallback != NULL) {
  979.             if (port->evtMask & C6X1X_EDMA_MCASP_EVT_RCKFAIL) { 
  980.                 MCASP_FSETSH(port->hMcasp, RINTCTL, RCKFAIL, DISABLE);
  981.                 while (MCASP_FGETH(port->hMcasp, RSTAT, RCKFAIL)) {
  982.                     MCASP_FSETSH(port->hMcasp, RSTAT, RCKFAIL, YES);
  983.                 }
  984.                 MCASP_FSETSH(port->hMcasp, RINTCTL, RCKFAIL, ENABLE);
  985.             }
  987.             IRQ_enable(MCASP_getRcvEventId(port->hMcasp));
  988.         }
  989.     } 
  990.     else { 
  991.         if (port->evtCallback != NULL) { 
  992.             if (port->evtMask & C6X1X_EDMA_MCASP_EVT_XCKFAIL) { 
  993.                 MCASP_FSETSH(port->hMcasp, XINTCTL, XCKFAIL, DISABLE);
  994.                 while (MCASP_FGETH(port->hMcasp, XSTAT, XCKFAIL)) {
  995.                     MCASP_FSETSH(port->hMcasp, XSTAT, XCKFAIL, YES);
  996.                 }
  997.                 MCASP_FSETSH(port->hMcasp, XINTCTL, XCKFAIL, ENABLE);
  998.             }
  1000.             IRQ_enable(MCASP_getXmtEventId(port->hMcasp));
  1001.         }
  1002.     }
  1003.     
  1004.     *chanp = (Ptr) chan;
  1005.     return (IOM_COMPLETED);
  1006. }
  1008. /*
  1009.  * ======== mdDeleteChan ========
  1010.  * This function frees a channel and all it's associated resources.
  1011.  */
  1012. static Int mdDeleteChan(Ptr chanp)
  1013. {
  1014.     ChanHandle chan = (ChanHandle) chanp;
  1015.     PortHandle port = chan->port;
  1017.     /* Clean up the channel resources */
  1018.     chanCleanUp(chan, DELCHAN);
  1020.     /*
  1021.      * Reset the McASP transmitter or receiver. If the channel is
  1022.      * recreated, mdCreateChan() will reenable the transmitter/receiver
  1023.      * and by pulling it out of reset it will also restart the EDMA channel.
  1024.      */
  1025.     if (chan->mode == INPUT) {
  1026.         MCASP_resetRcv(port->hMcasp);
  1027.     }
  1028.     else {
  1029.         MCASP_resetXmt(port->hMcasp);
  1030.     }
  1032.     return (IOM_COMPLETED);
  1033. }
  1035. /*
  1036.  * ======== mdSubmitChan ========
  1037.  * This function transmits a buffer to or from the McASP using the EDMA.
  1038.  */
  1039. static Int mdSubmitChan(Ptr chanp, IOM_Packet *packet)
  1040. {
  1041.     ChanHandle chan = (ChanHandle) chanp;
  1042.     PortHandle port = chan->port;
  1043.     Uns imask;
  1045.     /* No packets can be submitted while abort or flush is active */
  1046.     if (chan->flushPacket || chan->abortPacket) {
  1047.         return (IOM_EBADIO);
  1048.     }
  1050.     /*
  1051.      * Check to see if an abort command has been issued. Note that
  1052.      * flushing the input channel is handled the same as abort.
  1053.      */
  1054.     if ((packet->cmd == IOM_FLUSH && chan->mode == INPUT) ||
  1055.         packet->cmd == IOM_ABORT) {
  1057.         /* Disable interrupts to protect submitCount */
  1058.         imask = HWI_disable();
  1060.         /* Store the abort packet for the ISR to check */
  1061.         if (chan->submitCount > 0) {
  1062.             chan->abortPacket = packet;
  1064.             /*
  1065.              * Disable the EDMA channel while linking the currently
  1066.              * executing job while linking it with the Loop job to make
  1067.              * sure the currently executing job doesn't complete before
  1068.              * the link is complete.
  1069.              */
  1070.             EDMA_disableChannel(chan->xferPram);
  1071.             EDMA_link(chan->xferPram, chan->loophEdma);
  1072.             EDMA_enableChannel(chan->xferPram);
  1073.         }
  1075.         /* Reenable interrupts */
  1076.         HWI_restore(imask);
  1078.         if (chan->abortPacket) {
  1079.             return(IOM_PENDING);
  1080.         }
  1082.         /* If there were no buffers in the channel, return synchronously */
  1083.         packet->status = IOM_COMPLETED;
  1085.         return (IOM_COMPLETED);
  1086.     }
  1088.     /* Check to see if the submitted packet is an output flush packet */
  1089.     if (packet->cmd == IOM_FLUSH && chan->mode == OUTPUT) {
  1090.         /* Disable interrupts to protect submitCount */
  1091.         imask = HWI_disable();
  1093.         /* Store the flush packet for the ISR to check */
  1094.         if (chan->submitCount > 0) {
  1095.             chan->flushPacket = packet;
  1096.         }
  1098.         /* Reenable interrupts */
  1099.         HWI_restore(imask);
  1101.         if (chan->flushPacket) {
  1102.             return(IOM_PENDING);
  1103.         }
  1105.         /* If there were no buffers in the channel, return synchronously */
  1106.         packet->status = IOM_COMPLETED;
  1108.         return (IOM_COMPLETED);
  1109.     }
  1111.     if (packet->cmd != IOM_READ && packet->cmd != IOM_WRITE) {
  1112.         /* Unsupported command passed */
  1113.         return (IOM_ENOTIMPL);
  1114.     }
  1116.     /* maintain cache coherency */
  1117.     if (chan->mode == INPUT) {
  1118.         /* CACHE uses words, and packet->size is in nmaus (bytes on c6x) */
  1119.         if (port->cacheCalls) {
  1120.             CACHE_clean(CACHE_L2, packet->addr, packet->size >> 2);
  1121.         }
  1122.     }
  1123.     else {
  1124.         /* CACHE uses words, and packet->size is in nmaus (bytes on c6x) */
  1125.         if (port->cacheCalls) {
  1126.             CACHE_flush(CACHE_L2, packet->addr, packet->size >> 2);
  1127.         }
  1128.     }
  1130.     /* Disable interrupts to protect submitCount */
  1131.     imask = HWI_disable();
  1132.     /*
  1133.      * If there is no space available for the new packet, put it on a
  1134.      * queue to be linked in when space is available. Otherwise link it in.
  1135.      */
  1136.     if (chan->submitCount >= MAXLINKCNT) {
  1137.         QUE_enqueue(&chan->packetQueue, packet);
  1138.     }
  1139.     else {
  1140.         linkPacket(chan, packet);
  1141.     }
  1143.     chan->submitCount++;
  1145.     HWI_restore(imask);
  1147.     return (IOM_PENDING);
  1148. }
  1150. /*
  1151.  * ======== mdUnBindDev ========
  1152.  * This function frees a port and all it's associated resources.
  1153.  */
  1154. static Int mdUnBindDev(Ptr devp)
  1155. {
  1156.     PortHandle port = (PortHandle) devp;
  1158.     port->inUse = FALSE;
  1160.     /* Close the McASP */
  1161.     MCASP_close(port->hMcasp);
  1163.     return (IOM_COMPLETED);
  1164. }
  1166. /*
  1167.  * ======== C6X1X_EDMA_MCASP_init ========
  1168.  * This function initializes the driver's data structures.
  1169.  */
  1170. #pragma CODE_SECTION(C6X1X_EDMA_MCASP_init, ".text:init");
  1171. Void C6X1X_EDMA_MCASP_init()
  1172. {
  1173.     PortHandle port;
  1174.     ChanHandle chan;
  1175.     Int i, j;
  1176.     /* Make sure the initialization only happens once for thid driver */
  1177.     static Bool curInit = FALSE;
  1179.     if (curInit) {
  1180.         return;
  1181.     }
  1182.     curInit = TRUE;
  1184.     for (i=0; i<NUMPORTS; i++) {
  1185.         port = &ports[i];
  1187.         port->inUse = FALSE;
  1189.         for (j=0; j<NUMCHANS; j++) {
  1190.             chan = &port->chans[j];
  1192.             chan->inUse = FALSE;
  1193.         }
  1194.     }
  1195. }