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

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

DSP编程

开发平台：

C/C++

c5509_mmc.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.11.00.00 11-04-03 (ddk-b13)" */
  9. /*
  10.  * 
  11.  *  ======== c5509_mmc.c ========    
  12.  *
  13.  *
  14.  */
  16. #include <std.h>
  17. #include <hwi.h>
  18. #include <que.h>
  19. #include <iom.h>
  20. #include <c5509_mmc.h>
  23. /*  Native Mode Defines  */
  24. #define ENABLECLKPIN       1
  25. #define DAT3EDGEDETECTION  0
  27. /*  Number of Data Blocks */
  28. #define NBLK               1
  30. /*  Command Register Defines  */
  31. #define CMDDCLR            0x8000
  32. #define CMDDATA            0x2000
  33. #define CMDWRITE           0x0800
  35. /*  MMCST0 (Status Register 0)
  36.  *  Register fields prefixed with register name: ST0
  37.  */
  38. #define ST0WPED            0x1000
  39. #define ST0DATED           0x0800
  40. #define ST0DRRDY           0x0400
  41. #define ST0DXRDY           0x0200
  42. #define ST0SPIERR          0x0100
  43. #define ST0CRCRS           0x0080
  44. #define ST0CRCRD           0x0040
  45. #define ST0CRCWR           0x0020
  46. #define ST0TOUTRS          0x0010
  47. #define ST0TOUTRD          0x0008
  48. #define ST0RSPDNE          0x0004
  49. #define ST0BSYDNE          0x0002
  50. #define ST0DATDNE          0x0001
  52. /*  MMC IE Register Values
  53.  *  These defines are used to capture the interrupts that
  54.  *  are enabled in the corresponding operations being
  55.  *  performed on the MMC
  56.  */
  57. #define REGVALMMCIEREAD    MMC_MMCCIE_RMK(1,1,1,1,1,1,1,1,0,1,1)
  58. #define REGVALMMCIEWRITE   MMC_MMCCIE_RMK(1,0,1,0,1,1,0,1,1,0,0)
  59. #define REGVALMMCIESTATUS  MMC_MMCCIE_RMK(1,1,1,1,1,0,0,0,0,1,0)
  62. /*
  63.  *  MMC State Defines
  64.  *  These will be used to indicate the current state of a
  65.  *  request in the overall state machine.
  66.  *  Namespace definition for C5509_MMC_RdWrObj::stateParameter.
  67.  *  Internal states prefixed with IST.
  68.  */
  69. #define ISTBASEVALUE       0x1000  /* Base value for this namespace */
  70. #define ISTINVALID         (ISTBASEVALUE + 0)
  71.                                    /*
  72.                                     * Applicable to stateParameter
  73.                                     * and atomicStatus
  74.                                     */
  75. #define ISTSENDREAD        (ISTBASEVALUE + 1)
  76. #define ISTSENDWRITE       (ISTBASEVALUE + 2)
  77. #define ISTGETSTATUS       (ISTBASEVALUE + 3)
  78. #define ISTDATADONEREAD    (ISTBASEVALUE + 4)
  79. #define ISTDATADONEWRITE   (ISTBASEVALUE + 5)
  80. /*
  81.  *  Namespace definition for C5509_MMC_RdWrObj::atomicStatus.
  82.  */
  83. #define ISTATOMICWRITE     (ISTBASEVALUE + 6)
  84. #define ISTATOMICREAD      (ISTBASEVALUE + 7)
  86. /*  Read and Write sector length (in WORDs)  */
  87. #define SECLEN            C5509_MMC_SECLEN
  89. /*  CPU interrupt number for MMC  */
  91. #define INT7                7   /* DEV 0 */
  92. #define INT13              13   /* DEV 1 */
  94. /*  Operating Voltage 3.2-3.4V  */
  95. #define OPVOLTAGE          0x00300000
  97. #define CALLBACK(chan,packet,result)                                    
  98.             do {                                                        
  99.                 (packet)->status = (result);                            
  100.                 ((chan)->callback)((Ptr)(chan)->callbackArg, (packet)); 
  101.             } while(0)
  103. /* Driver Functions */
  104. static Int mdBindDev(Ptr* devp, Int devid, Ptr devParams);
  105. static Int mdControlChan(Ptr chanp, Uns cmd, Ptr arg);
  106. static Int mdCreateChan(Ptr *chanp, Ptr devp, String name, Int mode, 
  107.                 Ptr chanParams, IOM_TiomCallback cbFxn, Ptr cbArg);
  108. static Int mdDeleteChan(Ptr chanp);
  109. static Int mdSubmitChan(Ptr chanp, IOM_Packet *pPacket);
  111. /*  Helper Functions */
  112. static Int abortFlush(C5509_MMC_ChanObj *pChan, Uns cmd, IOM_Packet *pPacket);
  113. static Void issueReadWrite(IOM_Packet *pPacket, C5509_MMC_DevObj *ptrState);
  114. static Void handlerReadWrite(IOM_Packet *pPacket, 
  115.                 C5509_MMC_DevObj *ptrState, Uns error);
  117. /* MMC ISR */
  118. static Void isrMMC(Ptr ptrAttr);
  120. /*  MMC Reset Functions  */
  121. static Int initMMC(C5509_MMC_DevObj *ptrState, C5509_MMC_DevParams *mmcParams);
  122. static Int resetMMC(C5509_MMC_DevObj *ptrState);
  123. static Int reinitializeMMC(C5509_MMC_DevObj *ptrState);
  125. /*
  126.  * Public Mini Driver interface table.
  127.  */
  128. IOM_Fxns C5509_MMC_FXNS =
  129. {
  130.     &mdBindDev,
  131.     IOM_UNBINDDEVNOTIMPL,
  132.     &mdControlChan,
  133.     &mdCreateChan,
  134.     &mdDeleteChan,
  135.     &mdSubmitChan,
  136. };
  139. /*
  140.  *  ======== mdBindDev ========
  141.  *
  142.  *  Creates an instance of MMC device. Will be called to bind the device.
  143.  */
  145. static Int mdBindDev(Ptr* devp, Int devid, Ptr devParams)
  146. {
  147.     C5509_MMC_DevObj    *mmcHandle;
  148.     C5509_MMC_DevParams *mmcParams;
  149.     HWI_Attrs           attrs;
  150.     Int                 i;
  151.     
  152.     mmcParams = (C5509_MMC_DevParams *)devParams;
  153.     mmcHandle = (C5509_MMC_DevObj *)(*devp);
  154.     
  155.     if (*devp == NULL) {
  156.         return (IOM_EBADIO);
  157.     }
  159.     if (devParams == NULL) {
  160.         return (IOM_EBADARGS);  /* requires device params */
  161.     }
  163.     /* Check the version number */
  164.     if(mmcParams->versionId != C5509_MMC_VERSION_1){
  165.         return(IOM_EBADARGS);
  166.     }
  168.     /*  Fill up mmcHandle with mmcParams  */
  169.     mmcHandle->mmcDevNum = devid; /* MMC controller 0 or 1 */
  171.     /*  Copy structure containing all driver config parameters.  */
  172.     mmcHandle->drvrParams = mmcParams->drvrParams;
  174.     mmcHandle->blockLen = mmcParams->devParams.blockLen;
  175.     mmcHandle->currPacket = NULL;
  176.     mmcHandle->cslMMC = NULL;
  178.     mmcHandle->chOpenCount = 0;
  179.     
  180.     /*  Set all available channels as free  */
  181.     for (i = 0; i < mmcHandle->drvrParams.noChan; i++) {
  182.         mmcHandle->drvrParams.pChan[i].inUse = FALSE;
  183.     }
  184.     
  185.     /*  Reset the MMC before using it  */
  186.     if (initMMC (mmcHandle, mmcParams) != IOM_COMPLETED) {
  187.         return (IOM_EBADIO);
  188.     }
  189.     
  190.     /*  Create the pending request queue */
  191.     QUE_new (&mmcHandle->pendList);
  192.     
  193.     /*  Enable the MMC Interrupt  */
  194.     attrs.ier0mask = mmcParams->ier0Mask;
  195.     attrs.ier1mask = mmcParams->ier1Mask;
  196.     attrs.arg = (Arg)(*devp);
  197.     HWI_dispatchPlug ((devid == 0) ? INT7 : INT13, (Fxn)isrMMC, &attrs);
  199.     /* Successfully initialized, so return */
  200.     return (IOM_COMPLETED);
  201. }
  204. /*
  205.  *  ======== mdControlChan ========
  206.  * 
  207.  *  The Mini driver control function. 
  208.  *  Currently supports 2 commands - querying media type and 
  209.  *  reinitializing the MMC (after unplug/plug)
  210.  */
  212. static Int mdControlChan(Ptr chanp, Uns cmd, Ptr arg)
  213. {
  214.     C5509_MMC_ChanObj   *mmcChan;
  215.     
  216.     mmcChan = (C5509_MMC_ChanObj *)chanp;
  218.     switch (cmd) {
  220.         case MEDIA_CTRL_GETMEDIATYPE:
  221.             *(Int *)arg = C5509_MMC_MEDIATYPE;
  222.             return (IOM_COMPLETED);
  224.         case MEDIA_CTRL_REINITIALIZE:
  225.             if (reinitializeMMC (mmcChan->pHandle) != IOM_COMPLETED) {
  226.                 *(Int *)arg = MEDIA_NOTPRESENT;
  227.             }
  228.             else {
  229.                 *(Int *)arg = MEDIA_PRESENT;
  230.             }
  232.             return (IOM_COMPLETED);
  234.         default:
  235.             return (IOM_ENOTIMPL);
  236.     }
  237. }
  240. /*
  241.  *  ======== mdCreateChan ========
  242.  *
  243.  *  Creates an instance of channel object which will be used 
  244.  *  in future for sending commands on a particular channel 
  245.  */
  246.  
  247. static Int mdCreateChan(Ptr *chanp, Ptr devp, String name, Int mode, 
  248.                         Ptr chanParams, IOM_TiomCallback cbFxn, Ptr cbArg)
  249. {
  250.     C5509_MMC_DevObj    *mmcHandle;
  251.     C5509_MMC_ChanObj   *mmcChan;
  252.     Int                 i;
  253.     Int                 found;
  254.     Uns                 intrMask;
  255.      
  256.     mmcHandle = (C5509_MMC_DevObj *)devp;
  257.     found = -1;
  259.     if (mode != IOM_INOUT) {
  260.         return (IOM_EBADMODE);
  261.     }
  262.     
  263.     /*
  264.      *  inUse is not really checked in the ISR - so this serialization is
  265.      *  primarily to avoid multiple application-level threads of control
  266.      *  to gain access to the same resource
  267.      */
  268.     intrMask = HWI_disable();
  270.     /*  Checking for free channels  */
  271.     for (i = 0; i < mmcHandle->drvrParams.noChan; i++) {
  272.         if (mmcHandle->drvrParams.pChan[i].inUse == FALSE) {
  273.             found = i;
  274.             mmcHandle->drvrParams.pChan[i].inUse = TRUE;
  276.             if (mmcHandle->chOpenCount == 0) {
  277.                 IRQ_enable ((mmcHandle->mmcDevNum == 0) ? INT7 : INT13);
  278.             }
  279.             mmcHandle->chOpenCount++;
  281.             break;
  282.         }
  283.     }
  284.     
  285.     HWI_restore (intrMask);
  287.     /*  If no Channel is free, return error  */
  288.     if (found == -1) {
  289.         return (IOM_EALLOC);
  290.     }
  291.     
  292.     /*  Allocate the channel and mark it as INUSE.  */
  293.     mmcChan = &(mmcHandle->drvrParams.pChan[found]);
  294.     mmcChan->mode = mode;
  295.     mmcChan->pHandle = mmcHandle;
  296.     mmcChan->callback = cbFxn; 
  297.     mmcChan->callbackArg = cbArg;
  298.     
  299.     *chanp = &(mmcHandle->drvrParams.pChan[found]);
  300.     
  301.     return (IOM_COMPLETED);
  302. }
  304. /*
  305.  *  ======== mdSubmitChan ========
  306.  *  
  307.  *  This function provides read,write,abort and flush 
  308.  *  functionality to the application. 
  309.  */
  310.  
  311. static Int mdSubmitChan(Ptr chanp, IOM_Packet *pPacket)
  312. {
  313.     C5509_MMC_ChanObj    *mmcChan;
  314.     C5509_MMC_RdWrObj    *mediaStr;
  315.     C5509_MMC_RdWrObj    *currStr;
  316.     Int                  status;
  317.     Uns                  intrMask;
  318.     
  319.     mmcChan = (C5509_MMC_ChanObj *)chanp;
  320.     mediaStr = (C5509_MMC_RdWrObj *)pPacket->addr;
  321.     mediaStr->pChan = (C5509_MMC_ChanObj *)chanp;
  322.     
  323.     switch (pPacket->cmd) {
  324.         case IOM_READ:
  325.         case IOM_WRITE:
  326.         
  327.             /*  initialize mediastr */
  328.             mediaStr->count = 0;
  329.             mediaStr->atomicStatus = ISTINVALID;
  330.             mediaStr->stateParameter = ISTINVALID;
  332.             if (pPacket->cmd == IOM_WRITE && mediaStr->length != SECLEN) {
  333.                 pPacket->cmd = IOM_READ;
  334.                 mediaStr->atomicStatus = ISTATOMICREAD;
  335.                 mediaStr->stateParameter = ISTGETSTATUS;
  336.             }
  338.             intrMask = HWI_disable();
  340.             /*  Que this request if already currPacket has something */
  341.             if (mmcChan->pHandle->currPacket != NULL) {
  342.                 QUE_enqueue (&mmcChan->pHandle->pendList, pPacket);
  343.                 HWI_restore (intrMask);
  344.             }
  345.             else { 
  346.                 /* since there is nothing pending, process this request */
  347.                 mmcChan->pHandle->currPacket = pPacket;
  348.                 HWI_restore (intrMask);
  350.                 mediaStr->stateParameter = ISTGETSTATUS;
  351.                 _MMC_MMCCIE_SET (mmcChan->pHandle->mmcDevNum,
  352.                     REGVALMMCIESTATUS);
  353.                 MMC_sendCmd (mmcChan->pHandle->cslMMC, MMC_SEND_STATUS,
  354.                     mmcChan->pHandle->drvrParams.mmcCardId,
  355.                     MMC_STUFF_BITS, 0);
  356.             }
  358.             return (IOM_PENDING);
  359.         
  360.         case IOM_FLUSH:
  361.         case IOM_ABORT:
  362.             pPacket->addr = (C5509_MMC_ChanObj *)mmcChan;
  364.             intrMask = HWI_disable();
  366.             if (mmcChan->pHandle->currPacket != NULL) {
  367.                 currStr = (C5509_MMC_RdWrObj *)
  368.                                 mmcChan->pHandle->currPacket->addr;
  370.                 /* 
  371.                  *  if queue is empty and current packet is not for this 
  372.                  *  channel, then just return 
  373.                  */
  374.                 if (QUE_empty (&mmcChan->pHandle->pendList) &&
  375.                         currStr->pChan != mediaStr->pChan) {
  376.                     status = IOM_COMPLETED;
  377.                     goto FLUSHDONE;
  378.                 }
  379.             }
  380.             else {
  381.                 /*  
  382.                  *  this means current packet is null, 
  383.                  *  check if the queue is empty, if so return
  384.                  */
  385.                 if (QUE_empty (&mmcChan->pHandle->pendList)) {
  386.                     status = IOM_COMPLETED;
  387.                     goto FLUSHDONE;
  388.                 }
  389.             }
  390.         
  391.             status = abortFlush (mmcChan, pPacket->cmd, pPacket);
  393. FLUSHDONE:
  394.             HWI_restore (intrMask);
  396.             return (status);
  397.             
  398.         default:
  399.             return (IOM_ENOTIMPL);
  400.     }
  401. }
  403. /*
  404.  *  ======== mdDeleteChan ========
  405.  *
  406.  *  Deletes an instance of a channel object
  407.  */
  408.  
  409. static Int mdDeleteChan(Ptr chanp)
  410. {
  411.     C5509_MMC_ChanObj   *mmcChan;
  412.     Uns                 intrMask;
  413.     
  414.     mmcChan = (C5509_MMC_ChanObj *)chanp;
  415.     
  416.     intrMask = HWI_disable();
  418.     /*  Set the channel as free.  */
  419.     mmcChan->inUse = FALSE;
  421.     mmcChan->pHandle->chOpenCount--;
  422.     if (mmcChan->pHandle->chOpenCount == 0) {
  423.         IRQ_disable ((mmcChan->pHandle->mmcDevNum == 0) ? INT7 : INT13);
  424.     }
  425.     
  426.     HWI_restore (intrMask);
  428.     return (IOM_COMPLETED);
  429. }
  431.  
  432. /*
  433.  *  ======== abortFlush ========
  434.  * 
  435.  *  This function takes care of performing abort and flush operations
  436.  *  on a given channel.
  437.  *  This function is called with interrupts disabled.
  438.  */
  440. static Int abortFlush(C5509_MMC_ChanObj *mmcChan, Uns cmd, IOM_Packet *pPack)
  441. {
  442.     QUE_Elem           *qelem;
  443.     QUE_Elem           *tempElem;
  444.     QUE_Elem           *waitElem;
  445.     IOM_Packet         *pPacket;
  446.     C5509_MMC_RdWrObj  *mediaStr;
  447.     Int                retval;
  449.     waitElem = NULL;
  450.     
  451.     /* Unless a WRITE is pending in case of FLUSH this would not change */
  452.     retval = IOM_COMPLETED;
  454.     /* get pointer to first element in the queue */
  455.     qelem = QUE_head (&mmcChan->pHandle->pendList);
  456.     
  457.     /* 
  458.      *  Traverse through the request queue and identify
  459.      *  the request for this particular channel. 
  460.      *  For abort command, complete all the requests with
  461.      *  an error status and remove them from the queue.
  462.      *  For flush command, complete all read requests with
  463.      *  error status and remove them from the queue.
  464.      */
  465.     while (qelem != &mmcChan->pHandle->pendList) {
  466.         pPacket = (IOM_Packet *)qelem;
  467.         mediaStr = (C5509_MMC_RdWrObj *)pPacket->addr;
  469.         if (mediaStr->pChan == mmcChan) {
  470.             if ((cmd == IOM_FLUSH && pPacket->cmd == IOM_READ &&
  471.                     mediaStr->atomicStatus != ISTATOMICREAD) ||
  472.                     cmd == IOM_ABORT) {
  473.                 Int    status;
  475.                 if (cmd == IOM_FLUSH) {
  476.                     status = IOM_FLUSHED;
  477.                 }
  478.                 else {
  479.                     status = IOM_ABORTED;
  480.                 }
  481.                 tempElem = qelem;
  482.                 qelem = QUE_next (qelem);
  483.                 QUE_remove (tempElem);
  484.                 CALLBACK (mediaStr->pChan, pPacket, status);
  486.                 continue;
  487.             }
  488.             /*  This element tracks the last pending write in the queue  */
  489.             waitElem = qelem;
  490.         }
  491.         qelem = QUE_next(qelem);
  492.     }
  494.     /*
  495.      *  Now insert IOM_FLUSH packet in the queue so that it is processed
  496.      *  after all write-requests have completed
  497.      */
  499.     if (waitElem == NULL) {
  500.         pPacket = mmcChan->pHandle->currPacket;
  501.         mediaStr = (C5509_MMC_RdWrObj *)pPacket->addr;
  502.         /*
  503.          *  If a write operation is in progress on the current channel,
  504.          *  wait for it to complete.
  505.          */
  506.         if ((mediaStr->pChan == mmcChan) &&
  507.                 ((pPacket->cmd == IOM_WRITE) ||
  508.                  (pPacket->cmd == IOM_READ
  509.                     && mediaStr->atomicStatus == ISTATOMICREAD))) {
  510.             waitElem = QUE_head (&mmcChan->pHandle->pendList);
  511.             QUE_insert (waitElem, pPack);
  512.             retval = IOM_PENDING;
  513.         }
  514.     }
  515.     else {
  516.         waitElem = QUE_next (waitElem);
  517.         QUE_insert (waitElem, pPack);
  518.         retval = IOM_PENDING;
  519.     }
  520.     
  521.     /*
  522.      * if pPack is queued, it would be queued with pPack->status
  523.      * as IOM_PENDING, which is also sematically correct
  524.      */
  525.     pPack->status = retval;
  526.     
  527.     return (retval);
  528. }
  530. /*
  531.  *  ======== issueReadWrite ========
  532.  *  
  533.  *  Function for issuing the Read and Write Command
  534.  *  Called from the ISR - in interrupt context.
  535.  */
  537. static Void issueReadWrite(IOM_Packet *pPacket, C5509_MMC_DevObj *ptrState)
  538. {
  539.     C5509_MMC_RdWrObj  *mediaStr;
  540.     LgUns              address;
  541.     LgUns              sectorNumber;
  542.     MdUns              track;
  543.     
  544.     mediaStr = (C5509_MMC_RdWrObj *)pPacket->addr;
  545.     sectorNumber = mediaStr->sectorNumber;
  546.     address = sectorNumber << 9;
  548.     if (pPacket->cmd == IOM_WRITE) {
  549.         if ((mediaStr->length == SECLEN) || mediaStr->offset == 0) {
  550.             track = mediaStr->buf[0];
  551.         }
  552.         else {
  553.             /* in this case, atomicStatus == ISTATOMICWRITE */
  554.             track = mediaStr->pChan->pHandle->buf[0];
  555.         }
  557.         /* check if the byte-order needs to change */
  558.         if (ptrState->drvrParams.byteOrder == MEDIA_BYTESWAP) {
  559.             track = MEDIA_SWAPBYTES (track);
  560.         }
  562.         /* load the data transmission register with the first word */
  563.         _MMC_MMCDXR_SET (mediaStr->pChan->pHandle->mmcDevNum, track);
  564.     }
  565.     
  566.     /*  Set the Number of Blocks needed to be read, in this case it is 1 */
  567.     _MMC_MMCNBLK_SET (mediaStr->pChan->pHandle->mmcDevNum, NBLK);
  568.     
  569.     /*  Set the Block Length  */
  570.     _MMC_MMCBLEN_SET (mediaStr->pChan->pHandle->mmcDevNum,
  571.                       mediaStr->pChan->pHandle->blockLen);
  572.     
  573.     /*  Set the value of ARGL  */
  574.     _MMC_MMCARGL_SET (mediaStr->pChan->pHandle->mmcDevNum,
  575.                       (MdUns)(address & 0xFFFF));
  576.     
  577.     /*  Set the value of ARGH  */
  578.     _MMC_MMCARGH_SET (mediaStr->pChan->pHandle->mmcDevNum,
  579.                       (MdUns)((address >> 16) & 0xFFFF));
  580.     
  581.     /*  Check for COMMAND and send a READ or WRITE command.  */
  582.     if (pPacket->cmd == IOM_WRITE) {
  583.         _MMC_MMCCMD_SET (mediaStr->pChan->pHandle->mmcDevNum,
  584.             MMC_WRITE_BLOCK | CMDDATA | CMDDCLR | CMDWRITE);
  585.     }
  586.     else if (pPacket->cmd == IOM_READ) {
  587.         _MMC_MMCCMD_SET (mediaStr->pChan->pHandle->mmcDevNum,
  588.             MMC_READ_SINGLE_BLOCK | CMDDATA | CMDDCLR);
  589.     }
  590. }
  592. /*
  593.  *  ======== handlerReadWrite ========
  594.  *  
  595.  *  Read and Write Data from and to the MMC 
  596.  *  Called from the ISR - in interrupt context.
  597.  */
  599. static Void handlerReadWrite(IOM_Packet *pPacket,
  600.                              C5509_MMC_DevObj *ptrState, Uns error)
  601. {
  602.     C5509_MMC_ChanObj *afChan;
  603.     C5509_MMC_RdWrObj *mediaStr;
  604.     MdUns             k; 
  605.     Int               newRequest = 0;
  606.     Int               track = 0;
  607.     Int               flag = 1;
  608.     
  609.     mediaStr  = (C5509_MMC_RdWrObj *)pPacket->addr;
  610.     
  611.     /* 
  612.      *  afChan is used to store the channel pointer as it 
  613.      *  is not provided in the request for ABORT and FLUSH.
  614.      *  So we need to store it so that it can be used to 
  615.      *  call the callback function, in case of ABORT and FLUSH.
  616.      */
  617.     afChan = mediaStr->pChan;
  618.     if (pPacket->cmd == IOM_READ) {
  619.         k = _MMC_MMCDRR_GET (ptrState->mmcDevNum);
  620.         
  621.         /*  Loading the buffer with the new data.  */
  622.         if (mediaStr->count < SECLEN) {
  623.             if (mediaStr->count >= mediaStr->offset && 
  624.                 mediaStr->count < (mediaStr->length + mediaStr->offset)) {
  625.                 if (mediaStr->atomicStatus != ISTATOMICREAD) {
  626.                     if (ptrState->drvrParams.byteOrder == MEDIA_BYTESWAP) {
  627.                         mediaStr->buf[mediaStr->count - mediaStr->offset] =
  628.                                                             MEDIA_SWAPBYTES(k);
  629.                     }
  630.                     else {
  631.                         mediaStr->buf[mediaStr->count - mediaStr->offset] = k;
  632.                     }
  633.                 }
  634.             }
  635.             else if (mediaStr->atomicStatus == ISTATOMICREAD) {
  636.                 ptrState->buf[mediaStr->count] = k;
  637.             }
  638.         }
  639.         
  640.         /*  Incrementing the count of words read by one.  */
  641.         mediaStr->count++; 
  642.         
  643.         /*  
  644.          *  If the entire sector has been read, set the 
  645.          *  stateParameter to ISTDATADONEREAD
  646.          */
  647.         if (mediaStr->count >= SECLEN) {
  648.             mediaStr->stateParameter = ISTDATADONEREAD;
  649.         }
  650.         
  651.         /*  State where the request will call the callback.  */
  652.         if (mediaStr->count > SECLEN) {
  653.             if (error) {
  654.                 /*  Re-set the cmd, if it had been changed earlier */
  655.                 pPacket->cmd = (mediaStr->atomicStatus == ISTATOMICREAD)
  656.                                ? IOM_WRITE
  657.                                : IOM_READ;
  658.                 CALLBACK (mediaStr->pChan, pPacket, IOM_EBADIO); 
  660.                 /*  No further requests are scheduled - await reset */
  661.                 ptrState->currPacket = NULL;
  662.                 return;
  663.             }
  665.             if (mediaStr->atomicStatus == ISTATOMICREAD) {
  666.                 pPacket->cmd = IOM_WRITE;
  667.                 mediaStr->atomicStatus = ISTATOMICWRITE;
  668.                 mediaStr->count = 0;
  669.                 newRequest = 1;
  670.             }
  671.             else if (mediaStr->atomicStatus != ISTATOMICREAD) {
  672.                 CALLBACK (mediaStr->pChan, pPacket, IOM_COMPLETED); 
  674.                 ptrState->currPacket =
  675.                         (IOM_Packet *)QUE_dequeue (&ptrState->pendList);
  677.                 if ((QUE_Elem *)ptrState->currPacket != &ptrState->pendList) {
  678.                     newRequest = 1;
  679.                 }
  680.                 else {
  681.                     ptrState->currPacket = NULL;
  682.                 }
  683.             }
  684.         }
  685.     }
  686.     else if (pPacket->cmd == IOM_WRITE) {
  687.         /*  
  688.          *  If the entire sector has been written to, set the 
  689.          *  stateParameter to ISTDATADONEWRITE.
  690.          */
  691.         if (mediaStr->count >= SECLEN) {
  692.             mediaStr->stateParameter = ISTDATADONEWRITE;
  693.         }
  695.         /*  State where the request will call the callback.  */
  696.         if (mediaStr->count > SECLEN) {
  697.             if (error) {
  698.                 CALLBACK (mediaStr->pChan, pPacket, IOM_EBADIO); 
  700.                 /*  No further requests are scheduled - await reset */
  701.                 ptrState->currPacket = NULL;
  702.                 return;
  703.             }
  705.             CALLBACK (mediaStr->pChan, pPacket, IOM_COMPLETED); 
  707.             ptrState->currPacket = (IOM_Packet *)QUE_dequeue (&ptrState->pendList);
  709.             if ((QUE_Elem *)ptrState->currPacket != &ptrState->pendList) {
  710.                 newRequest = 1;
  711.             }
  712.             else {
  713.                 ptrState->currPacket = NULL;
  714.             }
  715.             
  716.             flag = 0;
  717.         }
  719.         if (flag) {
  720.             if (mediaStr->atomicStatus == ISTATOMICWRITE) {
  721.                 if (mediaStr->count >= mediaStr->offset &&
  722.                         mediaStr->count < (mediaStr->length +
  723.                                            mediaStr->offset)) {
  724.                     track = mediaStr->buf[mediaStr->count - mediaStr->offset];
  725.                 }
  726.                 else {
  727.                     track = ptrState->buf[mediaStr->count];
  728.                 }
  729.             }
  730.             else {
  731.                 track = mediaStr->buf[mediaStr->count];
  732.             }
  734.             if (ptrState->drvrParams.byteOrder == MEDIA_BYTESWAP) {
  735.                 track = MEDIA_SWAPBYTES (track);
  736.             }
  737.             _MMC_MMCDXR_SET (ptrState->mmcDevNum, track);
  739.             mediaStr->count++; 
  740.         }
  741.     }
  742.     
  743.     /*  
  744.      *  Checking for new requests in the request queue. 
  745.      *  In case of ABORT and FLUSH call the callback, else 
  746.      *  execute the request.
  747.      */
  748.     if (newRequest == 1) {
  749.         if ((ptrState->currPacket->cmd == IOM_ABORT) ||
  750.                 (ptrState->currPacket->cmd == IOM_FLUSH)) {
  751.             afChan = (C5509_MMC_ChanObj *)ptrState->currPacket->addr;
  752.             CALLBACK (afChan, ptrState->currPacket, IOM_COMPLETED); 
  754.             ptrState->currPacket = (IOM_Packet *)QUE_dequeue (&ptrState->pendList);
  755.             if ((QUE_Elem *)ptrState->currPacket != &ptrState->pendList) {
  756.                 newRequest = 1;
  757.             }
  758.             else {
  759.                 newRequest = 0;
  760.                 ptrState->currPacket = NULL;
  761.             }
  762.         }
  763.         
  764.         if (newRequest == 1) {
  765.             mediaStr = (C5509_MMC_RdWrObj *)ptrState->currPacket->addr;
  766.             mediaStr->stateParameter = ISTGETSTATUS;
  767.             _MMC_MMCCIE_SET (ptrState->mmcDevNum, REGVALMMCIESTATUS);
  768.             MMC_sendCmd (ptrState->cslMMC,MMC_SEND_STATUS,
  769.                 mediaStr->pChan->pHandle->drvrParams.mmcCardId,
  770.                 MMC_STUFF_BITS, 0);
  771.         }
  772.     }
  773. }
  775. /*
  776.  *  ======== isrMMC ========
  777.  *  
  778.  *  Interrupt handler for MMC
  779.  */
  781. static Void isrMMC(Ptr ptrAttr)
  782. {
  783.     C5509_MMC_DevObj  *ptrState = (C5509_MMC_DevObj *)ptrAttr;
  784.     IOM_Packet        *pPacket = ptrState->currPacket;
  785.     C5509_MMC_RdWrObj *mediaStr;
  786.     volatile Uns      regST0;
  787.     Uns               busy;
  788.     Uns               error;
  789.     
  790.     error = 0;
  792.     if (pPacket == NULL) {
  793.         return;
  794.     }
  795.     
  796.     mediaStr = (C5509_MMC_RdWrObj *)pPacket->addr;
  797.     regST0 = _MMC_MMCST0_GET (ptrState->mmcDevNum);
  798.     
  799.     switch (mediaStr->stateParameter) {
  800.        
  801.         case ISTGETSTATUS:
  802.                /*
  803.                 *  Check busy incase of RSPDNE.
  804.                 *  If busy resend MMC_SEND_STATUS else we proceed.
  805.                 */
  806.             if (regST0 & ST0RSPDNE) { 
  807.                 busy = ((_MMC_MMCRSP6_GET (ptrState->mmcDevNum) >> 8) & 1);
  809.                 if (!busy) {
  810.                     MMC_sendCmd (ptrState->cslMMC, MMC_SEND_STATUS, 
  811.                         mediaStr->pChan->pHandle->drvrParams.mmcCardId,
  812.                         MMC_STUFF_BITS, 0);
  813.                 }
  814.                 else {
  815.                     if (pPacket->cmd == IOM_READ) {
  816.                         _MMC_MMCCIE_SET (ptrState->mmcDevNum,
  817.                             REGVALMMCIEREAD);
  818.                         mediaStr->stateParameter = ISTSENDREAD;
  819.                         issueReadWrite (pPacket, ptrState);
  820.                     }
  821.                     else if (pPacket->cmd == IOM_WRITE) {
  822.                         _MMC_MMCCIE_SET (ptrState->mmcDevNum,
  823.                             REGVALMMCIEWRITE);
  824.                         regST0 = _MMC_MMCST0_GET (ptrState->mmcDevNum);
  825.                         mediaStr->stateParameter = ISTSENDWRITE;
  826.                         issueReadWrite (pPacket, ptrState);
  827.                     }
  828.                 }
  829.             }
  830.             else if (regST0 & ST0TOUTRS) {
  831.                 CALLBACK (mediaStr->pChan, pPacket, IOM_EBADIO); 
  832.                 ptrState->currPacket = NULL;
  833.             }
  834.             break;
  835.         
  836.         case ISTSENDREAD:
  837.             if (regST0 & ST0DRRDY) {
  838.                 _MMC_MMCST0_SET (ptrState->mmcDevNum, 0x0000);
  839.                 handlerReadWrite (pPacket, ptrState, error);
  840.             }
  841.             else if (regST0 & (ST0CRCRD | ST0CRCRS | ST0TOUTRD | ST0TOUTRS)) {
  842.                 CALLBACK (mediaStr->pChan, pPacket, IOM_EBADIO); 
  843.                 ptrState->currPacket = NULL;
  844.             }
  845.             break;
  846.         
  847.         case ISTSENDWRITE:
  848.             if (regST0 & ST0DXRDY) {
  849.                 handlerReadWrite (pPacket, ptrState, error);
  850.             }
  851.             else if (regST0 & (ST0CRCWR | ST0TOUTRS)) {
  852.                 CALLBACK (mediaStr->pChan, pPacket, IOM_EBADIO); 
  853.                 ptrState->currPacket = NULL;
  854.             }    
  855.             break;
  856.         
  857.         case ISTDATADONEREAD:
  858.             /*  Check if DATA done bit is set.  */
  859.             if (!(regST0 & ST0DATDNE) && (regST0 & ST0CRCRD)) {
  860.                 error = 1;
  861.             }
  862.             handlerReadWrite (pPacket, ptrState, error); 
  863.             break;
  864.             
  865.         case ISTDATADONEWRITE:
  866.             /*  Check if DATA done bit is set.  */
  867.             if (!(regST0 & ST0DATDNE) && (regST0 & ST0DRRDY)) {
  868.                 error = 1;
  869.             }
  870.             handlerReadWrite (pPacket, ptrState, error);
  871.             break;
  873.         default:
  874.             break;
  875.     } 
  876.     return;
  877. }
  879. /*
  880.  *  ======== resetMMC ========
  881.  *  
  882.  *  Resets the cards and selects it. This is a helper function called
  883.  *  by initMMC() and reinitializeMMC().
  884.  */
  885. static Int resetMMC(C5509_MMC_DevObj *ptrState)
  886. {
  887.     /*  Sets the operational voltage range.  */
  888.     if (MMC_sendOpCond (ptrState->cslMMC, OPVOLTAGE)) {
  889.         return (IOM_EBADIO);
  890.     }
  891.     
  892.     /*  Send broadcast command to all cards to identify themselves.  */
  893.     if (!MMC_sendAllCID (ptrState->cslMMC, &ptrState->cslMMC->cards->cid)) {
  894.         return (IOM_EBADIO);
  895.     }
  896.     
  897.     /*  Set the relative address.  */
  898.     if (!MMC_setRca (ptrState->cslMMC, ptrState->cslMMC->cards, 
  899.             ptrState->drvrParams.mmcCardId)) {
  900.         return (IOM_EBADIO);
  901.     }
  902.     
  903.     /*  Select the card.  */
  904.     if (!MMC_selectCard (ptrState->cslMMC, ptrState->cslMMC->cards)) {
  905.         return (IOM_EBADIO);
  906.     }
  908.     return (IOM_COMPLETED);
  909. }
  911. /*
  912.  *  ======== initMMC ========
  913.  *  
  914.  *  Initialization of the device takes place here, this is called during
  915.  *  bind dev. Initializes and selects a given card.
  916.  */
  917. static Int initMMC(C5509_MMC_DevObj *ptrState, C5509_MMC_DevParams *mmcParams)
  918. {
  919.     Int               retval;
  920.     Uns               intrMask;
  921.     volatile LgUns    delay = 30000;
  922.     
  923.     intrMask = HWI_disable ();
  925.     /*  Reserves the MMC device, specified by mmcDevNumber.  */
  926.     ptrState->cslMMC = MMC_open (ptrState->mmcDevNum);
  927.     if (ptrState->cslMMC == NULL) {
  928.         HWI_restore (intrMask);
  929.         return (IOM_EBADIO);
  930.     }
  931.     ptrState->cslMMC->cards = &ptrState->cslCards;
  932.     
  933.     /*  All except these two parameters are supplied by the application.  */
  934.     mmcParams->devParams.dat3EdgeDetection = DAT3EDGEDETECTION; 
  935.     mmcParams->devParams.enableClkPin = ENABLECLKPIN; 
  936.     
  937.     /*  Initialize the controller in native mode.  */
  938.     MMC_setupNative (ptrState->cslMMC, &mmcParams->devParams);
  939.     
  940.     /*  Send a broadcast GO_IDLE command.  */
  941.     MMC_sendGoIdle (ptrState->cslMMC);
  942.     
  943.     /*  Sufficient delay is needed for the MMC to reset.  */
  944.     while (delay--) {
  945.     }
  947.     if ((retval = resetMMC (ptrState)) != IOM_COMPLETED) {
  948.         MMC_close (ptrState->cslMMC);
  949.         ptrState->cslMMC = (MMC_Handle)NULL;
  950.     }
  952.     /*  Look at logic carefully before adding a statement here.  */
  953.     HWI_restore (intrMask);
  954.     return (retval);
  955. }
  957. /*
  958.  *  ======== reinitializeMMC ========
  959.  *  
  960.  *  Re-initializes the MMC and selects the card.
  961.  *  This function should be called whenever the MMC in UnPlugged
  962.  *  and plugged back.
  963.  */
  964.  
  965. static inline Int reinitializeMMC(C5509_MMC_DevObj *ptrState)
  966. {
  967.     Int    retval;
  968.     Uns    intrMask;
  970.     intrMask = HWI_disable ();
  971.     retval = resetMMC (ptrState);
  972.     HWI_restore (intrMask);
  974.     return (retval);
  975. }
  977. /*
  978.  *  ======== C5509_MMC_init ========
  979.  *  
  980.  *  Initialization function.
  981.  */
  982. Void C5509_MMC_init()
  983. {
  984. }