PDL for FM0+  Version1.0
Peripheral Driverl Library for FM0+
C:/pdl_v10/library/driver/qprc/qprc.c
Go to the documentation of this file.
00001 /*******************************************************************************
00002 * Copyright (C) 2013 Spansion LLC. All Rights Reserved. 
00003 *
00004 * This software is owned and published by: 
00005 * Spansion LLC, 915 DeGuigne Dr. Sunnyvale, CA  94088-3453 ("Spansion").
00006 *
00007 * BY DOWNLOADING, INSTALLING OR USING THIS SOFTWARE, YOU AGREE TO BE BOUND 
00008 * BY ALL THE TERMS AND CONDITIONS OF THIS AGREEMENT.
00009 *
00010 * This software contains source code for use with Spansion 
00011 * components. This software is licensed by Spansion to be adapted only 
00012 * for use in systems utilizing Spansion components. Spansion shall not be 
00013 * responsible for misuse or illegal use of this software for devices not 
00014 * supported herein.  Spansion is providing this software "AS IS" and will 
00015 * not be responsible for issues arising from incorrect user implementation 
00016 * of the software.  
00017 *
00018 * SPANSION MAKES NO WARRANTY, EXPRESS OR IMPLIED, ARISING BY LAW OR OTHERWISE,
00019 * REGARDING THE SOFTWARE (INCLUDING ANY ACOOMPANYING WRITTEN MATERIALS), 
00020 * ITS PERFORMANCE OR SUITABILITY FOR YOUR INTENDED USE, INCLUDING, 
00021 * WITHOUT LIMITATION, THE IMPLIED WARRANTY OF MERCHANTABILITY, THE IMPLIED 
00022 * WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE OR USE, AND THE IMPLIED 
00023 * WARRANTY OF NONINFRINGEMENT.  
00024 * SPANSION SHALL HAVE NO LIABILITY (WHETHER IN CONTRACT, WARRANTY, TORT, 
00025 * NEGLIGENCE OR OTHERWISE) FOR ANY DAMAGES WHATSOEVER (INCLUDING, WITHOUT 
00026 * LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, 
00027 * LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS) ARISING FROM USE OR 
00028 * INABILITY TO USE THE SOFTWARE, INCLUDING, WITHOUT LIMITATION, ANY DIRECT, 
00029 * INDIRECT, INCIDENTAL, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOSS OF DATA, 
00030 * SAVINGS OR PROFITS, 
00031 * EVEN IF SPANSION HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 
00032 * YOU ASSUME ALL RESPONSIBILITIES FOR SELECTION OF THE SOFTWARE TO ACHIEVE YOUR
00033 * INTENDED RESULTS, AND FOR THE INSTALLATION OF, USE OF, AND RESULTS OBTAINED 
00034 * FROM, THE SOFTWARE.  
00035 *
00036 * This software may be replicated in part or whole for the licensed use, 
00037 * with the restriction that this Disclaimer and Copyright notice must be 
00038 * included with each copy of this software, whether used in part or whole, 
00039 * at all times.  
00040 */
00041 /******************************************************************************/
00052 /******************************************************************************/
00053 /* Include files                                                              */
00054 /******************************************************************************/
00055 #include "qprc.h"
00056 
00057 #if (defined(PDL_PERIPHERAL_QPRC_ACTIVE))
00058 
00063 /******************************************************************************/
00064 /* Local pre-processor symbols/macros ('#define')                             */
00065 /******************************************************************************/
00066 
00067 /******************************************************************************/
00068 /* Global variable definitions (declared in header file with 'extern')        */
00069 /******************************************************************************/
00070 
00071 /******************************************************************************/
00072 /* Local type definitions ('typedef')                                         */
00073 /******************************************************************************/
00074 
00075 /******************************************************************************/
00076 /* Local function prototypes ('static')                                       */
00077 /******************************************************************************/
00078 static en_result_t QprcIsValidQprcnPtr(volatile stc_qprcn_t *pstcQprc);
00079 static volatile stc_qprc_nfn_t* QprcGetNoisFilterPtr( volatile stc_qprcn_t *pstcQprc );
00080 #if (PDL_INTERRUPT_ENABLE_QPRC0 == PDL_ON) || \
00081     (PDL_INTERRUPT_ENABLE_QPRC1 == PDL_ON) || \
00082     (PDL_INTERRUPT_ENABLE_QPRC2 == PDL_ON) 
00083 static stc_qprc_intern_data_t *QprcGetInternDataPtr( volatile stc_qprcn_t *pstcQprc );
00084 #endif
00085 /******************************************************************************/
00086 /* Local variable definitions ('static')                                      */
00087 /******************************************************************************/
00088 
00089 /******************************************************************************/
00090 /* Function implementation - global ('extern') and local ('static')           */
00091 /******************************************************************************/
00093 stc_qprc_instance_data_t m_astcQprcInstanceDataLut[QPRC_INSTANCE_COUNT] =
00094 {
00095 #if (PDL_PERIPHERAL_ENABLE_QPRC0 == PDL_ON)
00096     {
00097         &QPRC0,   // pstcInstance QPRC
00098         &QPRCNF0, // pstcInstanceNf QPRC-NF
00099         {NULL,NULL,NULL,NULL,NULL,NULL}   // stcInternData (not initialized yet)
00100     },
00101 #endif
00102 #if (PDL_PERIPHERAL_ENABLE_QPRC1 == PDL_ON)
00103     {
00104         &QPRC1,   // pstcInstance QPRC
00105         &QPRCNF1, // pstcInstanceNf QPRC-NF
00106         {NULL,NULL,NULL,NULL,NULL,NULL}   // stcInternData (not initialized yet)
00107     },
00108 #endif
00109 #if (PDL_PERIPHERAL_ENABLE_QPRC2 == PDL_ON)
00110     {
00111         &QPRC2,   // pstcInstance QPRC
00112         &QPRCNF2, // pstcInstanceNf QPRC-NF
00113         {NULL,NULL,NULL,NULL,NULL,NULL}   // stcInternData (not initialized yet)
00114     },
00115 #endif
00116 
00117 };
00118 
00129 static en_result_t QprcIsValidQprcnPtr(volatile stc_qprcn_t *pstcQprc)
00130 {
00131     uint32_t u32Instance;
00132 
00133     if (NULL == pstcQprc)
00134     {
00135         return ErrorInvalidParameter;
00136     }
00137 
00138     for (u32Instance = 0; u32Instance < QPRC_INSTANCE_COUNT; u32Instance++)
00139     {
00140         if (pstcQprc == m_astcQprcInstanceDataLut[u32Instance].pstcInstance)
00141         {
00142             return Ok;
00143         }
00144     }
00145 
00146     return ErrorInvalidParameter;
00147 }
00148 
00158 static volatile stc_qprc_nfn_t *QprcGetNoisFilterPtr( volatile stc_qprcn_t *pstcQprc )
00159 {
00160     uint32_t u32Instance;
00161 
00162     for (u32Instance = 0; u32Instance < QPRC_INSTANCE_COUNT; u32Instance++)
00163     {
00164         if (pstcQprc == m_astcQprcInstanceDataLut[u32Instance].pstcInstance)
00165         {
00166             return m_astcQprcInstanceDataLut[u32Instance].pstcInstanceNf;
00167         }
00168     }
00169 
00170     return (volatile stc_qprc_nfn_t *)NULL;
00171 }
00172 
00173 
00174 #if (PDL_INTERRUPT_ENABLE_QPRC0 == PDL_ON) || \
00175     (PDL_INTERRUPT_ENABLE_QPRC1 == PDL_ON) || \
00176     (PDL_INTERRUPT_ENABLE_QPRC2 == PDL_ON) 
00177 
00186 static  stc_qprc_intern_data_t *QprcGetInternDataPtr( volatile stc_qprcn_t *pstcQprc )
00187 {
00188     uint32_t u32Instance;
00189 
00190     for (u32Instance = 0; u32Instance < QPRC_INSTANCE_COUNT; u32Instance++)
00191     {
00192         if (pstcQprc == m_astcQprcInstanceDataLut[u32Instance].pstcInstance)
00193         {
00194             return &m_astcQprcInstanceDataLut[u32Instance].stcInternData;
00195         }
00196     }
00197 
00198     return NULL;
00199 }      
00200       
00208 static void Qprc_InitNvic(volatile stc_qprcn_t* pstcQprc)
00209 {
00210     if ((pstcQprc == (volatile stc_qprcn_t*)(&QPRC0)) ||
00211         (pstcQprc == (volatile stc_qprcn_t*)(&QPRC1)) ||
00212         (pstcQprc == (volatile stc_qprcn_t*)(&QPRC2)))  
00213     {
00214         NVIC_ClearPendingIRQ(DTIM_QDU_IRQn);
00215         NVIC_EnableIRQ(DTIM_QDU_IRQn);
00216         NVIC_SetPriority(DTIM_QDU_IRQn, PDL_IRQ_LEVEL_DT_QPRC);
00217     }
00218 }
00219 
00227 static void Qprc_DeInitNvic(volatile stc_qprcn_t* pstcQprc)
00228 {
00229     FM0P_DTIM_TypeDef* pDtReg = ((FM0P_DTIM_TypeDef *)FM0P_DTIM_BASE);
00230     
00231     if ((pstcQprc == (volatile stc_qprcn_t*)(&QPRC0)) ||
00232         (pstcQprc == (volatile stc_qprcn_t*)(&QPRC1)) ||
00233         (pstcQprc == (volatile stc_qprcn_t*)(&QPRC2))) 
00234     {
00235         if((FM0P_QPRC0->QECR & 0x0004u) != 0x0000u) /* ORNGIE = 0? */
00236         {
00237             return;
00238         }
00239         
00240         if((FM0P_QPRC0->QICRL & 0x15u) != 0x00u) /* OUZIE=QPRCMIE=QPCMIE=0? */
00241         {
00242             return;
00243         }
00244         
00245         if((FM0P_QPRC0->QICRH & 0x01u) != 0x00u) /* CDCIE=0? */
00246         {
00247             return;
00248         }
00249         
00250         if((FM0P_QPRC1->QECR & 0x0004u) != 0x0000u) /* ORNGIE = 0? */
00251         {
00252             return;
00253         }
00254         
00255         if((FM0P_QPRC1->QICRL & 0x15u) != 0x00u) /* OUZIE=QPRCMIE=QPCMIE=0? */
00256         {
00257             return;
00258         }
00259         
00260         if((FM0P_QPRC1->QICRH & 0x01u) != 0x00u) /* CDCIE=0? */
00261         {
00262             return;
00263         }
00264         
00265         if((FM0P_QPRC2->QECR & 0x0004u) != 0x0000u) /* ORNGIE = 0? */
00266         {
00267             return;
00268         }
00269         
00270         if((FM0P_QPRC2->QICRL & 0x15u) != 0x00u) /* OUZIE=QPRCMIE=QPCMIE=0? */
00271         {
00272             return;
00273         }
00274         
00275         if((FM0P_QPRC2->QICRH & 0x01u) != 0x00u) /* CDCIE=0? */
00276         {
00277             return;
00278         }
00279         
00280         if((pDtReg->TIMERXCONTROL & 0x00000020u) != 0x00000000u) /* DT Int disable? */
00281         {
00282             return;
00283         }
00284         
00285         if(((pDtReg+1)->TIMERXCONTROL & 0x00000020u) != 0x00000000u) /* DT Int disable? */
00286         {
00287             return;
00288         }
00289         
00290         /* QPRC and DT interrupt are all disabled, disable this IRQ */ 
00291         NVIC_ClearPendingIRQ(DTIM_QDU_IRQn);
00292         NVIC_DisableIRQ(DTIM_QDU_IRQn);
00293         NVIC_SetPriority(DTIM_QDU_IRQn, PDL_DEFAULT_INTERRUPT_LEVEL);
00294         
00295     }
00296   
00297     return;
00298 }
00299 
00308 void Qprc_IrqHandler  ( volatile stc_qprcn_t *pstcQprc,
00309                        stc_qprc_intern_data_t *pstcQprcInternData )
00310 {
00311     if ((NULL == pstcQprc) ||
00312         (NULL == pstcQprcInternData))
00313     {
00314         return;
00315     }
00316 
00317     if (PdlSet == pstcQprc->QICRL_f.QPCMF)    // QPCCR match ?
00318     {
00319         pstcQprc->QICRL_f.QPCMF = PdlClr;    // Clear interrupt
00320         if (NULL != pstcQprcInternData->pfnPcMatchCallback)
00321         {
00322             pstcQprcInternData->pfnPcMatchCallback();
00323         }
00324     }
00325 
00326     if (PdlSet == pstcQprc->QICRL_f.QPRCMF)   // QPRCR match ?
00327     {
00328         pstcQprc->QICRL_f.QPRCMF = PdlClr;   // Clear interrupt
00329         if (NULL != pstcQprcInternData->pfnPcRcMatchCallback)
00330         {
00331             pstcQprcInternData->pfnPcRcMatchCallback();
00332         }
00333     }
00334 
00335     if (PdlSet == pstcQprc->QICRL_f.OFDF)    //Overflow Interrupe ?
00336     {
00337         pstcQprc->QICRL_f.OFDF = PdlClr;     // Clear interrupt
00338         if (NULL != pstcQprcInternData->pfnPcUfOfZeroCallback)
00339         {
00340             pstcQprcInternData->pfnPcUfOfZeroCallback(QPRC_PC_OVERFLOW_INT);
00341         }
00342     }
00343 
00344     if (PdlSet == pstcQprc->QICRL_f.UFDF)  //Underflow Interrupe ?
00345     {
00346         pstcQprc->QICRL_f.UFDF = PdlClr;   // Clear interrupt
00347         if (NULL != pstcQprcInternData->pfnPcUfOfZeroCallback)
00348         {
00349             pstcQprcInternData->pfnPcUfOfZeroCallback(QPRC_PC_UNDERFLOW_INT);
00350         }
00351     }
00352 
00353     if (PdlSet == pstcQprc->QICRL_f.ZIIF)    //Zero Interrupe ?
00354     {
00355         pstcQprc->QICRL_f.ZIIF = PdlClr;     // Clear interrupt
00356         if (NULL != pstcQprcInternData->pfnPcUfOfZeroCallback)
00357         {
00358             pstcQprcInternData->pfnPcUfOfZeroCallback(QPRC_PC_ZERO_INDEX_INT);
00359         }
00360     }
00361 
00362     if (PdlSet == pstcQprc->QICRH_f.CDCF)    //PC invert match ?
00363     {
00364         pstcQprc->QICRH_f.CDCF = PdlClr;     // Clear interrupt
00365         if (NULL != pstcQprcInternData->pfnPcCountInvertCallback)
00366         {
00367             pstcQprcInternData->pfnPcCountInvertCallback();
00368         }
00369     }
00370 
00371     if (PdlSet == pstcQprc->QECR_f.ORNGF)    //RC outrange ?
00372     {
00373         pstcQprc->QECR_f.ORNGF = PdlClr;     // Clear interrupt
00374         if (NULL != pstcQprcInternData->pfnRcOutrangeCallback)
00375         {
00376             pstcQprcInternData->pfnRcOutrangeCallback();
00377         }
00378     }
00379 
00380     if (PdlSet == pstcQprc->QICRH_f.QPCNRCMF)     //PcMatch and RcMatch ?
00381     {
00382         pstcQprc->QICRH_f.QPCNRCMF = PdlClr;      // Clear interrupt
00383         if (NULL != pstcQprcInternData->pfnPcMatchRcMatchCallback)
00384         {
00385             pstcQprcInternData->pfnPcMatchRcMatchCallback();
00386         }
00387     }
00388 
00389     return;
00390 }
00391 
00392 #endif
00393 
00410 en_result_t Qprc_Init( volatile stc_qprcn_t* pstcQprc,
00411                             stc_qprc_config_t*  pstcConfig )
00412 {
00413     volatile stc_qprc_nfn_t *pstcQprcInternNfn;
00414 
00415     if ( (Ok != QprcIsValidQprcnPtr(pstcQprc)) ||
00416          (NULL == pstcConfig)
00417        )
00418     {
00419         return ErrorInvalidParameter;
00420     }
00421 
00422     if (((pstcConfig->bSwapAinBin != TRUE) && (pstcConfig->bSwapAinBin != FALSE))||
00423         (pstcConfig->enComapreMode > QprcComapreWithRevolution) ||
00424         (pstcConfig->enZinEdge > QprcZinHighLevel) ||
00425         (pstcConfig->enBinEdge > QprcBinBothEdges) ||
00426         (pstcConfig->enAinEdge > QprcAinBothEdges) ||
00427         (pstcConfig->enPcResetMask > QprcResetMask8Times) ||
00428         (pstcConfig->stcAinFilter.enWidth > QprcFilterWidth256Pclk) ||
00429         (pstcConfig->stcBinFilter.enWidth > QprcFilterWidth256Pclk) ||
00430         (pstcConfig->stcCinFilter.enWidth > QprcFilterWidth256Pclk) ||
00431         ((pstcConfig->stcAinFilter.bInputMask != TRUE) && (pstcConfig->stcAinFilter.bInputMask != FALSE))||
00432         ((pstcConfig->stcBinFilter.bInputMask != TRUE) && (pstcConfig->stcBinFilter.bInputMask != FALSE))||
00433         ((pstcConfig->stcCinFilter.bInputMask != TRUE) && (pstcConfig->stcCinFilter.bInputMask != FALSE))||
00434         ((pstcConfig->stcAinFilter.bInputInvert != TRUE) && (pstcConfig->stcAinFilter.bInputInvert != FALSE))||
00435         ((pstcConfig->stcBinFilter.bInputInvert != TRUE) && (pstcConfig->stcBinFilter.bInputInvert != FALSE))||
00436         ((pstcConfig->stcCinFilter.bInputInvert != TRUE) && (pstcConfig->stcCinFilter.bInputInvert != FALSE)))
00437 
00438     {
00439         return ErrorInvalidParameter;
00440     }
00441 
00442     pstcQprc->QCRL_f.SWAP = (TRUE == pstcConfig->bSwapAinBin) ? 1 : 0 ;
00443     pstcQprc->QCRL_f.RSEL = pstcConfig->enComapreMode;
00444 
00445     switch (pstcConfig->enZinEdge)
00446     {
00447         case QprcZinDisable: // Disables edge and level detection
00448         {
00449             pstcQprc->QCRH_f.CGE = 0u;
00450         }
00451         break;
00452 
00453         case QprcZinFallingEdge: // ZIN active at falling edge
00454         {
00455             pstcQprc->QCRL_f.CGSC = 0u;            
00456             pstcQprc->QCRH_f.CGE = 1u;
00457         }
00458         break;
00459 
00460         case QprcZinRisingEdge: // ZIN active at rising edge
00461         {
00462             pstcQprc->QCRL_f.CGSC = 0u;            
00463             pstcQprc->QCRH_f.CGE = 2u;
00464         }
00465         break;
00466 
00467         case QprcZinBothEdges: // ZIN active at falling or rising edge
00468         {
00469             pstcQprc->QCRL_f.CGSC = 0u;   
00470             pstcQprc->QCRH_f.CGE = 3u;
00471         }
00472         break;
00473 
00474         case QprcZinLowLevel: // ZIN active at low level detected
00475         {
00476             pstcQprc->QCRL_f.CGSC = 1u; 
00477             pstcQprc->QCRH_f.CGE = 1u;
00478         }
00479         break;
00480 
00481         case QprcZinHighLevel: // ZIN active at high level detected
00482         {
00483             pstcQprc->QCRL_f.CGSC = 1;  
00484             pstcQprc->QCRH_f.CGE = 2u;
00485         }
00486         break;
00487 
00488         default:
00489             break;
00490     }
00491 
00492     switch (pstcConfig->enBinEdge)
00493     {
00494         case QprcBinDisable: // Disables edge detection
00495         {
00496             pstcQprc->QCRH_f.BES = 0u;
00497         }
00498         break;
00499 
00500         case QprcBinFallingEdge: // BIN active at falling edge
00501         {
00502             pstcQprc->QCRH_f.BES = 1u;
00503         }
00504         break;
00505 
00506         case QprcBinRisingEdge: // BIN active at rising edge
00507         {
00508             pstcQprc->QCRH_f.BES = 2u;
00509         }
00510         break;
00511 
00512         case QprcBinBothEdges: // BIN active at falling or rising edge
00513         {
00514             pstcQprc->QCRH_f.BES = 3u;
00515         }
00516         break;
00517 
00518         default:
00519             break;
00520     }
00521 
00522     switch (pstcConfig->enAinEdge)
00523     {
00524         case QprcBinDisable: // Disables edge detection
00525         {
00526             pstcQprc->QCRH_f.AES = 0u;
00527         }
00528         break;
00529 
00530         case QprcBinFallingEdge: // BIN active at falling edge
00531         {
00532             pstcQprc->QCRH_f.AES = 1u;
00533         }
00534         break;
00535 
00536         case QprcBinRisingEdge: // BIN active at rising edge
00537         {
00538             pstcQprc->QCRH_f.AES = 2u;
00539         }
00540         break;
00541 
00542         case QprcBinBothEdges: // BIN active at falling or rising edge
00543         {
00544             pstcQprc->QCRH_f.AES = 3u;
00545         }
00546         break;
00547 
00548         default:
00549             break;
00550     }
00551 
00552     switch (pstcConfig->enPcResetMask)
00553     {
00554         case QprcResetMaskDisable: // No reset mask
00555         {
00556             pstcQprc->QCRH_f.PCRM = 0u;
00557         }
00558         break;
00559 
00560         case QprcResetMask2Times:
00561         {
00562             pstcQprc->QCRH_f.PCRM = 1u;
00563         }
00564         break;
00565 
00566         case QprcResetMask4Times:
00567         {
00568             pstcQprc->QCRH_f.PCRM = 2u;
00569         }
00570         break;
00571 
00572         case QprcResetMask8Times:
00573         {
00574             pstcQprc->QCRH_f.PCRM = 3u;
00575         }
00576         break;
00577 
00578         default:
00579             break;
00580     }
00581 
00582     pstcQprc->QECR_f.ORNGMD = (TRUE == pstcConfig->b8KValue) ? 1 : 0 ; // TRUE: Outrange mode from 0 to 0x7FFF, FALSE: Outrange mode from 0 to 0xFFFF:
00583 
00584     /* Set QPRC Noise Filter */
00585     pstcQprcInternNfn = QprcGetNoisFilterPtr(pstcQprc);
00586 
00587     pstcQprcInternNfn->NFCTLA_f.AINMD = (TRUE == pstcConfig->stcAinFilter.bInputMask) ? 1 : 0 ;
00588     pstcQprcInternNfn->NFCTLA_f.AINLV = (TRUE == pstcConfig->stcAinFilter.bInputInvert) ? 1 : 0 ;
00589     pstcQprcInternNfn->NFCTLA_f.AINNWS = pstcConfig->stcAinFilter.enWidth;
00590 
00591     pstcQprcInternNfn->NFCTLB_f.BINMD = (TRUE == pstcConfig->stcBinFilter.bInputMask) ? 1 : 0 ;
00592     pstcQprcInternNfn->NFCTLB_f.BINLV = (TRUE == pstcConfig->stcBinFilter.bInputInvert) ? 1 : 0 ;
00593     pstcQprcInternNfn->NFCTLB_f.BINNWS = pstcConfig->stcBinFilter.enWidth;
00594 
00595     pstcQprcInternNfn->NFCTLZ_f.ZINMD = (TRUE == pstcConfig->stcCinFilter.bInputMask) ? 1 : 0 ;
00596     pstcQprcInternNfn->NFCTLZ_f.ZINLV = (TRUE == pstcConfig->stcCinFilter.bInputInvert) ? 1 : 0 ;
00597     pstcQprcInternNfn->NFCTLZ_f.ZINNWS = pstcConfig->stcCinFilter.enWidth;
00598 
00599     return Ok;
00600 }
00601 
00611 en_result_t Qprc_StopPcCount(volatile stc_qprcn_t *pstcQprc)
00612 {
00613     // Check for NULL pointer
00614     if (NULL == pstcQprc)
00615     {
00616         return ErrorInvalidParameter ;
00617     }
00618 
00619     pstcQprc->QCRL_f.PSTP = 1;
00620     return Ok;
00621 }
00622 
00632 en_result_t Qprc_RestartPcCount(volatile stc_qprcn_t *pstcQprc)
00633 {
00634     // Check for NULL pointer
00635     if (NULL == pstcQprc)
00636     {
00637         return ErrorInvalidParameter ;
00638     }
00639 
00640     pstcQprc->QCRL_f.PSTP = 0;
00641     return Ok;
00642 }
00643 
00654 en_result_t Qprc_SetPcCount ( volatile stc_qprcn_t *pstcQprc,
00655                                     uint16_t u16PcValue )
00656 {
00657     if (NULL == pstcQprc)
00658     {
00659         return ErrorInvalidParameter;
00660     }
00661 
00662     pstcQprc->QPCR = u16PcValue;
00663     return Ok;
00664 }
00665 
00676 uint16_t Qprc_GetPcCount ( volatile stc_qprcn_t *pstcQprc )
00677 {
00678     if (NULL == pstcQprc)
00679     {
00680         return 0xFFFFu;
00681     }
00682 
00683     return (uint16_t)pstcQprc->QPCR;
00684 }
00685 
00696 en_result_t Qprc_SetRcCount ( volatile stc_qprcn_t *pstcQprc,
00697                                     uint16_t u16RcValue )
00698 {
00699     if (NULL == pstcQprc)
00700     {
00701         return ErrorInvalidParameter;
00702     }
00703 
00704     pstcQprc->QRCR = u16RcValue;
00705     return Ok;
00706 }
00707 
00708 
00719 uint16_t Qprc_GetRcCount ( volatile stc_qprcn_t *pstcQprc )
00720 {
00721     if (NULL == pstcQprc)
00722     {
00723         return 0xFFFFu;
00724     }
00725 
00726     return (uint16_t)pstcQprc->QPCR;
00727 }
00728 
00739 en_result_t Qprc_SetPcMaxValue( volatile stc_qprcn_t *pstcQprc,
00740                                         uint16_t u16PcMaxValue )
00741 {
00742     if (NULL == pstcQprc)
00743     {
00744         return ErrorInvalidParameter;
00745     }
00746 
00747     pstcQprc->QMPR = u16PcMaxValue;
00748     return Ok;
00749 }
00750 
00761 uint16_t Qprc_GetPcMaxValue(volatile stc_qprcn_t *pstcQprc)
00762 {
00763     if (NULL == pstcQprc)
00764     {
00765         return 0xFFFFu;
00766     }
00767 
00768     return (uint16_t)pstcQprc->QMPR;
00769 }
00770 
00782 en_result_t Qprc_SetPcCompareValue( volatile stc_qprcn_t *pstcQprc,
00783                                     uint16_t u16PcValue )
00784 {
00785     if (NULL == pstcQprc)
00786     {
00787         return ErrorInvalidParameter;
00788     }
00789 
00790     pstcQprc->QPCCR = u16PcValue;
00791 
00792     return Ok;
00793 }
00794 
00804 uint16_t Qprc_GetPcCompareValue( volatile stc_qprcn_t *pstcQprc)
00805 {
00806     if (NULL == pstcQprc)
00807     {
00808         return ErrorInvalidParameter;
00809     }
00810 
00811     return (uint16_t)pstcQprc->QPCCR;
00812 }
00813 
00814 
00829 en_result_t Qprc_SetPcRcCompareValue( volatile stc_qprcn_t *pstcQprc,
00830                                                 uint16_t u16PcRcValue )
00831 {
00832     if (NULL == pstcQprc)
00833     {
00834         return ErrorInvalidParameter;
00835     }
00836 
00837     pstcQprc->QPRCR = u16PcRcValue;
00838 
00839     return Ok;
00840 }
00841 
00852 uint16_t Qprc_GetPcRcCompareValue(volatile stc_qprcn_t *pstcQprc)
00853 {
00854     if (NULL == pstcQprc)
00855     {
00856         return 0xFFFFu;
00857     }
00858 
00859     return (uint16_t)pstcQprc->QPRCR;
00860 }
00861 
00876 en_result_t Qprc_ConfigPcMode( volatile stc_qprcn_t *pstcQprc,
00877                                         en_qprc_pcmode_t enMode )
00878 {
00879     if ((NULL == pstcQprc) ||
00880         (enMode > QprcPcMode3))
00881     {
00882         return ErrorInvalidParameter;
00883     }
00884 
00885     switch(enMode)
00886     {
00887         case QprcPcMode0: //Disable position counter
00888         {
00889             pstcQprc->QCRL_f.PCM = 0u;
00890         }
00891         break;
00892 
00893         case QprcPcMode1: //Increments with AIN active edge and decrements with BIN active edge
00894         {
00895             pstcQprc->QCRL_f.PCM = 1u;
00896         }
00897         break;
00898 
00899         case QprcPcMode2: //Phase difference count mode: Counts up if AIN is leading BIN, down if BIN leading.
00900         {
00901             pstcQprc->QCRL_f.PCM = 2u;
00902         }
00903         break;
00904 
00905         case QprcPcMode3: // Directional count mode: Counts up/down with BIN active edge and AIN level
00906         {
00907             pstcQprc->QCRL_f.PCM = 3u;
00908         }
00909         break;
00910 
00911         default:
00912             return ErrorInvalidParameter;
00913     }
00914 
00915     return Ok;
00916 }
00917 
00931 en_result_t Qprc_ConfigRcMode( volatile stc_qprcn_t *pstcQprc,
00932                                         en_qprc_rcmode_t enMode )
00933 {
00934     if ((NULL == pstcQprc) ||
00935         (enMode > QprcRcMode3))
00936     {
00937         return ErrorInvalidParameter;
00938     }
00939 
00940     switch(enMode)
00941     {
00942         case QprcRcMode0:  
00943         {
00944             pstcQprc->QCRL_f.RCM = 0u;
00945         }
00946         break;
00947 
00948         case QprcRcMode1: //Up/down count of RC with ZIN active edge
00949         {
00950             pstcQprc->QCRL_f.RCM = 1u;
00951         }
00952         break;
00953 
00954         case QprcRcMode2: //Up/down count of RC on over or underflow in position count match
00955         {
00956             pstcQprc->QCRL_f.RCM = 2u;
00957         }
00958         break;
00959 
00960         case QprcRcMode3: //Up/down count of RC on over or underflow in position count match and ZIN active edge
00961         {
00962             pstcQprc->QCRL_f.RCM = 3u;
00963         }
00964         break;
00965 
00966         default:
00967             return ErrorInvalidParameter;
00968     }
00969 
00970     return Ok;
00971 }
00972 
00973 #if (PDL_INTERRUPT_ENABLE_QPRC0 == PDL_ON) || \
00974     (PDL_INTERRUPT_ENABLE_QPRC1 == PDL_ON) || \
00975     (PDL_INTERRUPT_ENABLE_QPRC2 == PDL_ON) || \
00976     (PDL_INTERRUPT_ENABLE_QPRC3 == PDL_ON)
00977 
00990 en_result_t Qprc_EnableInt( volatile stc_qprcn_t* pstcQprc, stc_qprc_int_sel_t* pstcIntSel,
00991                             stc_qprc_int_cb_t*  pstcIntCallback )
00992 {
00993     stc_qprc_intern_data_t *pstcQprcInternData = NULL;
00994     if ((NULL == pstcQprc) ||
00995        (pstcIntSel->bQprcPcCountInvertInt > 1) ||
00996        (pstcIntSel->bQprcPcMatchInt > 1) ||
00997        (pstcIntSel->bQprcPcMatchRcMatchInt > 1) ||
00998        (pstcIntSel->bQprcPcOfUfZeroInt > 1) ||
00999        (pstcIntSel->bQprcPcRcMatchInt > 1) ||
01000        (pstcIntSel->bQprcRcOutrangeInt > 1) ||
01001        (NULL == pstcIntCallback)  )
01002     {
01003         return ErrorInvalidParameter;
01004     }
01005 
01006     pstcQprcInternData = QprcGetInternDataPtr(pstcQprc);
01007 
01008     if (NULL == pstcQprcInternData)
01009     {
01010         return ErrorInvalidParameter;
01011     }
01012     if (TRUE == pstcIntSel->bQprcPcMatchInt)
01013     {
01014         pstcQprcInternData->pfnPcMatchCallback = pstcIntCallback->pfnPcMatchIntCallback;
01015         pstcQprc->QICRL_f.QPCMIE = 1;
01016     }
01017     if (TRUE == pstcIntSel->bQprcPcRcMatchInt)
01018     {
01019         pstcQprcInternData->pfnPcRcMatchCallback = pstcIntCallback->pfnPcRcMatchIntCallback;
01020         pstcQprc->QICRL_f.QPRCMIE = 1;
01021     }
01022     if (TRUE == pstcIntSel->bQprcPcMatchRcMatchInt)
01023     {
01024         pstcQprcInternData->pfnPcMatchRcMatchCallback = pstcIntCallback->pfnPcMatchRcMatchIntCallback;
01025         pstcQprc->QICRH_f.QPCNRCMIE = 1;
01026     }
01027     if (TRUE == pstcIntSel->bQprcPcOfUfZeroInt)
01028     {
01029         pstcQprcInternData->pfnPcUfOfZeroCallback = pstcIntCallback->pfnPcOfUfZeroIntCallback;
01030         pstcQprc->QICRL_f.OUZIE = 1;
01031     }
01032     if (TRUE == pstcIntSel->bQprcPcCountInvertInt)
01033     {
01034         pstcQprcInternData->pfnPcCountInvertCallback = pstcIntCallback->pfnPcCountInvertIntCallback;
01035         pstcQprc->QICRH_f.CDCIE = 1;
01036     }
01037     if (TRUE == pstcIntSel->bQprcRcOutrangeInt)
01038     {
01039         pstcQprcInternData->pfnRcOutrangeCallback = pstcIntCallback->pfnRcOutrangeIntCallback;
01040         pstcQprc->QECR_f.ORNGIE = 1;
01041     }
01042 
01043     Qprc_InitNvic(pstcQprc);
01044 
01045     return Ok;
01046 }
01047 
01060 en_result_t Qprc_DisableInt( volatile stc_qprcn_t* pstcQprc, stc_qprc_int_sel_t* pstcIntSel )
01061 {
01062     stc_qprc_intern_data_t *pstcQprcInternData = NULL;
01063     if((NULL == pstcQprc) ||
01064        (pstcIntSel->bQprcPcCountInvertInt > 1) ||
01065        (pstcIntSel->bQprcPcMatchInt > 1) ||
01066        (pstcIntSel->bQprcPcMatchRcMatchInt > 1) ||
01067        (pstcIntSel->bQprcPcOfUfZeroInt > 1) ||
01068        (pstcIntSel->bQprcPcRcMatchInt > 1) ||
01069        (pstcIntSel->bQprcRcOutrangeInt > 1))
01070     {
01071         return ErrorInvalidParameter;
01072     }
01073 
01074     pstcQprcInternData = QprcGetInternDataPtr(pstcQprc);
01075 
01076     if (NULL == pstcQprcInternData)
01077     {
01078         return ErrorInvalidParameter;
01079     }
01080     if (TRUE == pstcIntSel->bQprcPcMatchInt)
01081     {
01082         pstcQprcInternData->pfnPcMatchCallback = NULL;
01083         pstcQprc->QICRL_f.QPCMIE = 0;
01084     }
01085     if (TRUE == pstcIntSel->bQprcPcRcMatchInt)
01086     {
01087         pstcQprcInternData->pfnPcRcMatchCallback = NULL;
01088         pstcQprc->QICRL_f.QPRCMIE = 0;
01089     }
01090     if (TRUE == pstcIntSel->bQprcPcMatchRcMatchInt)
01091     {
01092         pstcQprcInternData->pfnPcMatchRcMatchCallback = NULL;
01093         pstcQprc->QICRH_f.QPCNRCMIE = 0;
01094     }
01095     if (TRUE == pstcIntSel->bQprcPcOfUfZeroInt)
01096     {
01097         pstcQprcInternData->pfnPcUfOfZeroCallback = NULL;
01098         pstcQprc->QICRL_f.OUZIE = 0;
01099     }
01100     if (TRUE == pstcIntSel->bQprcPcCountInvertInt)
01101     {
01102         pstcQprcInternData->pfnPcCountInvertCallback = NULL;
01103         pstcQprc->QICRH_f.CDCIE = 0;
01104     }
01105     if (TRUE == pstcIntSel->bQprcRcOutrangeInt)
01106     {
01107         pstcQprcInternData->pfnRcOutrangeCallback = NULL;
01108         pstcQprc->QECR_f.ORNGIE = 0;
01109     }
01110 
01111     Qprc_DeInitNvic(pstcQprc);
01112 
01113     return Ok;
01114 }
01115 
01116 #endif
01117 
01128 en_int_flag_t Qprc_GetIntFlag( volatile stc_qprcn_t *pstcQprc,
01129                                     en_qprc_int_t enIntType)
01130 {
01131     en_int_flag_t enIntFlag = PdlClr;
01132 
01133     if ((NULL == pstcQprc) ||
01134         (enIntType > QprcRcOutrangeInt))
01135     {
01136         return PdlClr;
01137     }
01138 
01139     switch(enIntType)
01140     {
01141         case QprcPcOfUfZeroInt:
01142             if(PdlSet == pstcQprc->QICRL_f.ZIIF)
01143             {
01144                 enIntFlag = PdlSet;
01145                 break;
01146             }
01147             
01148             if(PdlSet == pstcQprc->QICRL_f.OFDF)
01149             {
01150                 enIntFlag = PdlSet;
01151                 break;
01152             }
01153             
01154             if(PdlSet == pstcQprc->QICRL_f.UFDF)
01155             {
01156                 enIntFlag = PdlSet;
01157                 break;
01158             }
01159             break;
01160 
01161         case QprcPcMatchInt:
01162             enIntFlag = (1 == pstcQprc->QICRL_f.QPCMF) ? PdlSet : PdlClr ;
01163             break;
01164 
01165         case QprcPcRcMatchInt:
01166             enIntFlag = (1 == pstcQprc->QICRL_f.QPRCMF) ? PdlSet : PdlClr ;
01167             break;
01168 
01169         case QprcPcMatchRcMatchInt:
01170             enIntFlag = (1 == pstcQprc->QICRH_f.QPCNRCMF) ? PdlSet : PdlClr ;
01171             break;
01172 
01173         case QprcPcCountInvertInt:
01174             enIntFlag = (1 == pstcQprc->QICRH_f.CDCF) ? PdlSet : PdlClr ;
01175             break;
01176 
01177         case QprcRcOutrangeInt:
01178             enIntFlag = (1 == pstcQprc->QECR_f.ORNGF) ? PdlSet : PdlClr ;
01179             break;
01180 
01181         default:
01182             break;
01183     }
01184 
01185     return enIntFlag;
01186 }
01187 
01188 
01202 en_result_t Qprc_ClrIntFlag( volatile stc_qprcn_t *pstcQprc,
01203                                 en_qprc_int_t enIntType)
01204 {
01205     if ((NULL == pstcQprc) ||
01206         (enIntType > QprcRcOutrangeInt))
01207     {
01208         return ErrorInvalidParameter;
01209     }
01210 
01211     switch(enIntType)
01212     {
01213         case QprcPcOfUfZeroInt:
01214         {
01215             pstcQprc->QICRL_f.ZIIF = PdlClr;
01216             pstcQprc->QICRL_f.OFDF = PdlClr;
01217             pstcQprc->QICRL_f.UFDF = PdlClr;
01218         }
01219         break;
01220 
01221         case QprcPcMatchInt:
01222         {
01223             pstcQprc->QICRL_f.QPCMF = PdlClr;
01224         }
01225         break;
01226 
01227         case QprcPcRcMatchInt:
01228         {
01229             pstcQprc->QICRL_f.QPRCMF = PdlClr;
01230         }
01231         break;
01232 
01233         case QprcPcMatchRcMatchInt:
01234         {
01235             pstcQprc->QICRH_f.QPCNRCMF = PdlClr;
01236         }
01237         break;
01238 
01239         case QprcPcCountInvertInt:
01240         {
01241             pstcQprc->QICRH_f.CDCF = PdlClr;
01242         }
01243         break;
01244 
01245         case QprcRcOutrangeInt:
01246         {
01247             pstcQprc->QECR_f.ORNGF = PdlClr;
01248         }
01249         break;
01250 
01251         default:
01252             break;
01253     }
01254 
01255     return Ok;
01256 
01257 }
01258 
01268 en_stat_flag_t Qprc_GetPcOfUfDir( volatile stc_qprcn_t *pstcQprc )
01269 {
01270     en_stat_flag_t enStatFlag = PdlClr;
01271 
01272     if (NULL == pstcQprc)
01273     {
01274         return PdlClr;
01275     }
01276 
01277     enStatFlag = (1 == pstcQprc->QICRH_f.DIROU) ? PdlSet : PdlClr ;
01278     return enStatFlag;
01279 }
01280 
01290 en_stat_flag_t Qprc_GetPcDir( volatile stc_qprcn_t *pstcQprc )
01291 {
01292     en_stat_flag_t enStatFlag = PdlClr;
01293 
01294     if (NULL == pstcQprc)
01295     {
01296         return PdlClr;
01297     }
01298 
01299     enStatFlag = (1 == pstcQprc->QICRH_f.DIRPC) ? PdlSet : PdlClr ;
01300 
01301     return enStatFlag;
01302 }
01303 
01304 
01305 
01307 
01308 
01309 #endif // #if (defined(PDL_PERIPHERAL_QPRC_ACTIVE))
01310 
01311 /******************************************************************************/
01312 /* EOF (not truncated)                                                        */
01313 /******************************************************************************/