![]() |
PDL for FM0+
Version1.0
Peripheral Driverl Library for FM0+
|
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 /******************************************************************************/ 00054 /******************************************************************************/ 00055 /* Include files */ 00056 /******************************************************************************/ 00057 #include "mft_ocu.h" 00058 00059 #if (defined(PDL_PERIPHERAL_MFT_OCU_ACTIVE)) 00060 00066 00067 /******************************************************************************/ 00068 /* Local pre-processor symbols/macros ('#define') */ 00069 /******************************************************************************/ 00070 /******************************************************************************/ 00071 /* Global variable definitions (declared in header file with 'extern') */ 00072 /******************************************************************************/ 00074 stc_mft_ocu_instance_data_t m_astcMftOcuInstanceDataLut[OCU_INSTANCE_COUNT] = 00075 { 00076 #if (PDL_PERIPHERAL_ENABLE_MFT0_OCU == PDL_ON) 00077 { 00078 &MFT0_OCU, // pstcInstance 00079 {NULL, NULL, NULL, NULL, NULL, NULL} // stcInternData (not initialized yet) 00080 }, 00081 #endif 00082 #if (PDL_PERIPHERAL_ENABLE_MFT1_OCU == PDL_ON) 00083 { 00084 &MFT1_OCU, // pstcInstance 00085 {NULL, NULL, NULL, NULL, NULL, NULL} // stcInternData (not initialized yet) 00086 }, 00087 #endif 00088 #if (PDL_PERIPHERAL_ENABLE_MFT2_OCU == PDL_ON) 00089 { 00090 &MFT2_OCU, // pstcInstance 00091 {NULL, NULL, NULL, NULL, NULL, NULL} // stcInternData (not initialized yet) 00092 }, 00093 #endif 00094 }; 00095 00096 /******************************************************************************/ 00097 /* Local type definitions ('typedef') */ 00098 /******************************************************************************/ 00099 00100 /******************************************************************************/ 00101 /* Local function prototypes ('static') */ 00102 /******************************************************************************/ 00103 00104 /******************************************************************************/ 00105 /* Local variable definitions ('static') */ 00106 /******************************************************************************/ 00107 00108 /******************************************************************************/ 00109 /* Function implementation - global ('extern') and local ('static') */ 00110 /******************************************************************************/ 00121 static stc_mft_ocu_intern_data_t* MftGetInternDataPtr(volatile stc_mftn_ocu_t* pstcOcu) 00122 { 00123 uint32_t u32Instance; 00124 00125 for (u32Instance = 0; u32Instance < OCU_INSTANCE_COUNT; u32Instance++) 00126 { 00127 if (pstcOcu == m_astcMftOcuInstanceDataLut[u32Instance].pstcInstance) 00128 { 00129 return &m_astcMftOcuInstanceDataLut[u32Instance].stcInternData; 00130 } 00131 } 00132 00133 return NULL; 00134 } 00135 00136 #if (PDL_INTERRUPT_ENABLE_MFT0_OCU == PDL_ON) || \ 00137 (PDL_INTERRUPT_ENABLE_MFT1_OCU == PDL_ON) || \ 00138 (PDL_INTERRUPT_ENABLE_MFT2_OCU == PDL_ON) 00139 00147 void Mft_Ocu_IrqHandler( volatile stc_mftn_ocu_t* pstcOcu, 00148 stc_mft_ocu_intern_data_t* pstcMftOcuInternData) 00149 { 00150 func_ptr_t funCallBack; 00151 uint32_t* ptemp; 00152 uint8_t Ch; 00153 00154 //lookup the handler 00155 for(Ch=0;Ch<MFT_OCU_MAXCH;Ch++) 00156 { 00157 if(PdlSet == Mft_Ocu_GetIntFlag(pstcOcu,Ch)) 00158 { 00159 //clear the interrupt flag 00160 Mft_Ocu_ClrIntFlag(pstcOcu,Ch); 00161 00162 //pointer callback function address 00163 ptemp = (uint32_t*)&(pstcMftOcuInternData->pfnOcu0Callback); 00164 funCallBack = (func_ptr_t)(*(ptemp + Ch)); 00165 00166 if(funCallBack != NULL) 00167 { 00168 funCallBack(); 00169 } 00170 } 00171 } 00172 } 00173 00184 static void Mft_Ocu_InitIrq( volatile stc_mftn_ocu_t* pstcOcu ) 00185 { 00186 if ((pstcOcu == (volatile stc_mftn_ocu_t*)(&MFT0_OCU)) || 00187 (pstcOcu == (volatile stc_mftn_ocu_t*)(&MFT1_OCU)) || 00188 (pstcOcu == (volatile stc_mftn_ocu_t*)(&MFT2_OCU))) 00189 { 00190 NVIC_ClearPendingIRQ(OUTCOMP_IRQn); 00191 NVIC_EnableIRQ(OUTCOMP_IRQn); 00192 NVIC_SetPriority(OUTCOMP_IRQn, PDL_IRQ_LEVEL_MFT_OCU); 00193 } 00194 00195 return ; 00196 } 00197 00207 static void Mft_Ocu_DeInitIrq( volatile stc_mftn_ocu_t* pstcOcu ) 00208 { 00209 if ((pstcOcu == (volatile stc_mftn_ocu_t*)(&MFT0_OCU)) || 00210 (pstcOcu == (volatile stc_mftn_ocu_t*)(&MFT1_OCU)) || 00211 (pstcOcu == (volatile stc_mftn_ocu_t*)(&MFT2_OCU))) 00212 { 00213 if(pstcOcu->OCSA10_f.IOE0 == 1) 00214 { 00215 return; 00216 } 00217 if(pstcOcu->OCSA10_f.IOE1 == 1) 00218 { 00219 return; 00220 } 00221 if(pstcOcu->OCSA32_f.IOE0 == 1) 00222 { 00223 return; 00224 } 00225 if(pstcOcu->OCSA32_f.IOE1 == 1) 00226 { 00227 return; 00228 } 00229 if(pstcOcu->OCSA54_f.IOE0 == 1) 00230 { 00231 return; 00232 } 00233 if(pstcOcu->OCSA54_f.IOE1 == 1) 00234 { 00235 return; 00236 } 00237 00238 NVIC_ClearPendingIRQ(OUTCOMP_IRQn); 00239 NVIC_DisableIRQ(OUTCOMP_IRQn); 00240 NVIC_SetPriority(OUTCOMP_IRQn, PDL_DEFAULT_INTERRUPT_LEVEL); 00241 } 00242 00243 return; 00244 } 00245 00246 #endif 00247 00248 /******************************************************************************/ 00249 /* Local Functions */ 00250 /******************************************************************************/ 00251 00270 en_result_t Mft_Ocu_Init( volatile stc_mftn_ocu_t* pstcOcu, 00271 uint8_t u8Ch, stc_mft_ocu_config_t* pstcOcuConfig) 00272 { 00273 stc_mft_ocu_intern_data_t* pstcOcuInternData; 00274 volatile uint8_t* pu8OCFS; 00275 volatile stc_mft_ocu_ocsb10_field_t* pstcOCSB; 00276 volatile uint8_t* p8OCSC; 00277 volatile uint8_t* pu8OCSD; 00278 00279 // Check for NULL pointer and configuration parameter 00280 if ( (pstcOcu == NULL) || 00281 (u8Ch >= MFT_OCU_MAXCH) || 00282 (pstcOcuConfig->enFrtConnect > OcuFrtToExt) || 00283 (pstcOcuConfig->bFm4 > 1) || 00284 (pstcOcuConfig->bCmod > 1) || 00285 (pstcOcuConfig->enOccpBufMode > OccpBufTrsfByFrtZeroPeak ) || 00286 (pstcOcuConfig->enOcseBufMode > OcseBufTrsfByFrtZeroPeak ) ) 00287 { 00288 return ErrorInvalidParameter ; 00289 } 00290 // Get pointer to internal data structure ... 00291 pstcOcuInternData = MftGetInternDataPtr( pstcOcu ) ; 00292 // ... and check for NULL 00293 if ( pstcOcuInternData != NULL ) 00294 { 00295 pstcOcuInternData->pfnOcu0Callback = NULL; 00296 pstcOcuInternData->pfnOcu1Callback = NULL; 00297 pstcOcuInternData->pfnOcu2Callback = NULL; 00298 pstcOcuInternData->pfnOcu3Callback = NULL; 00299 pstcOcuInternData->pfnOcu4Callback = NULL; 00300 pstcOcuInternData->pfnOcu5Callback = NULL; 00301 } 00302 00303 //Get pointer of current channel OCU register address 00304 pu8OCFS = (volatile uint8_t*)((volatile uint8_t*)pstcOcu + 0x68UL + u8Ch/2); 00305 pstcOCSB = (volatile stc_mft_ocu_ocsb10_field_t*)((volatile uint8_t*)pstcOcu + 0x19UL + (u8Ch/2)*4); 00306 p8OCSC = (volatile uint8_t*)((volatile uint8_t*)pstcOcu + 0x25UL); 00307 pu8OCSD = (volatile uint8_t*)((volatile uint8_t*)pstcOcu + 0x1AUL + (u8Ch/2)*4); 00308 00309 //set OCSB register, config ocu's operation 00310 pstcOCSB->CMOD = pstcOcuConfig->bCmod; 00311 pstcOCSB->FM4 = pstcOcuConfig->bFm4; 00312 00313 //set OCSC register, when enable FM3 compatible mode 00314 *p8OCSC = pstcOcuConfig->u8Mod; 00315 00316 //set OCSD register and RT output level state 00317 if(0 == (u8Ch % 2)) //channel 0, 2, 4 00318 { 00319 *pu8OCSD &= 0x33u; 00320 *pu8OCSD |= (uint8_t)pstcOcuConfig->enOccpBufMode; 00321 *pu8OCSD |= (uint8_t)((uint8_t)pstcOcuConfig->enOcseBufMode << 4); 00322 *pu8OCFS |= (uint8_t)pstcOcuConfig->enFrtConnect; 00323 pstcOCSB->OTD0 = pstcOcuConfig->enStatePin; 00324 } 00325 else//channel 1, 3, 5 00326 { 00327 *pu8OCSD &= 0xCCu; 00328 *pu8OCSD |= (uint8_t)((uint8_t)pstcOcuConfig->enOccpBufMode << 2); 00329 *pu8OCSD |= (uint8_t)((uint8_t)pstcOcuConfig->enOcseBufMode << 6); 00330 *pu8OCFS |= (uint8_t)((uint8_t)pstcOcuConfig->enFrtConnect << 4); 00331 pstcOCSB->OTD1 = pstcOcuConfig->enStatePin; 00332 } 00333 00334 return Ok; 00335 } 00336 00354 en_result_t Mft_Ocu_SetEvenChCompareMode(volatile stc_mftn_ocu_t* pstcOcu, 00355 uint8_t EvenCh, 00356 stc_even_compare_config_t* pstcConfig) 00357 { 00358 volatile uint16_t* p16OCSE0; 00359 00360 // Check for NULL pointer 00361 if ( (pstcOcu == NULL) 00362 || (EvenCh%2 != 0) 00363 || (pstcConfig == NULL) 00364 || (pstcConfig->enFrtZeroEvenMatchEvenChRtStatus > RtOutputReverse) 00365 || (pstcConfig->enFrtZeroEvenNotMatchEvenChRtStatus > RtOutputReverse) 00366 || (pstcConfig->enFrtUpCntEvenMatchEvenChRtStatus > RtOutputReverse) 00367 || (pstcConfig->enFrtPeakEvenMatchEvenChRtStatus > RtOutputReverse) 00368 || (pstcConfig->enFrtPeakEvenNotMatchEvenChStatus > RtOutputReverse) 00369 || (pstcConfig->enFrtDownCntEvenMatchEvenChRtStatus > RtOutputReverse) 00370 || (pstcConfig->enIopFlagWhenFrtZeroEvenMatch > IopFlagSet) 00371 || (pstcConfig->enIopFlagWhenFrtUpCntEvenMatch > IopFlagSet) 00372 || (pstcConfig->enIopFlagWhenFrtPeakEvenMatch > IopFlagSet) 00373 || (pstcConfig->enIopFlagWhenFrtDownCntEvenMatch > IopFlagSet) ) 00374 { 00375 return ErrorInvalidParameter ; 00376 } 00377 00378 p16OCSE0 = (volatile uint16_t*)((volatile uint8_t*)pstcOcu + 0x28UL + EvenCh*4); 00379 *p16OCSE0 = 0; 00380 *p16OCSE0 |= (uint16_t)((uint16_t)pstcConfig->enFrtZeroEvenMatchEvenChRtStatus << 10u); 00381 *p16OCSE0 |= (uint16_t)((uint16_t)pstcConfig->enFrtZeroEvenNotMatchEvenChRtStatus << 14u); 00382 *p16OCSE0 |= (uint16_t)((uint16_t)pstcConfig->enFrtUpCntEvenMatchEvenChRtStatus << 8u); 00383 *p16OCSE0 |= (uint16_t)((uint16_t)pstcConfig->enFrtPeakEvenMatchEvenChRtStatus << 6u); 00384 *p16OCSE0 |= (uint16_t)((uint16_t)pstcConfig->enFrtPeakEvenNotMatchEvenChStatus << 12u); 00385 *p16OCSE0 |= (uint16_t)((uint16_t)pstcConfig->enFrtDownCntEvenMatchEvenChRtStatus << 4u); 00386 *p16OCSE0 |= (uint16_t)((uint16_t)pstcConfig->enIopFlagWhenFrtZeroEvenMatch << 3u); 00387 *p16OCSE0 |= (uint16_t)((uint16_t)pstcConfig->enIopFlagWhenFrtUpCntEvenMatch << 2u); 00388 *p16OCSE0 |= (uint16_t)((uint16_t)pstcConfig->enIopFlagWhenFrtPeakEvenMatch << 1u); 00389 *p16OCSE0 |= (uint16_t)((uint16_t)pstcConfig->enIopFlagWhenFrtDownCntEvenMatch << 0u); 00390 return Ok; 00391 } 00392 00410 en_result_t Mft_Ocu_SetOddChCompareMode (volatile stc_mftn_ocu_t*pstcOcu, 00411 uint8_t OddCh, 00412 stc_odd_compare_config_t* pstcConfig) 00413 { 00414 volatile uint32_t* pu32OCSE1; 00415 00416 // Check for NULL pointer 00417 if ( (pstcOcu == NULL) 00418 || (OddCh%2 == 0) 00419 || (pstcConfig->enFrtZeroOddMatchEvenMatchOddChRtStatus > RtOutputReverse) 00420 || (pstcConfig->enFrtZeroOddMatchEvenNotMatchOddChRtStatus > RtOutputReverse) 00421 || (pstcConfig->enFrtZeroOddNotMatchEvenMatchOddChRtStatus > RtOutputReverse) 00422 || (pstcConfig->enFrtZeroOddNotMatchEvenNotMatchOddChRtStatus > RtOutputReverse) 00423 || (pstcConfig->enFrtUpCntOddMatchEvenMatchOddChRtStatus > RtOutputReverse) 00424 || (pstcConfig->enFrtUpCntOddMatchEvenNotMatchOddChRtStatus > RtOutputReverse) 00425 || (pstcConfig->enFrtUpCntOddNotMatchEvenMatchOddChRtStatus > RtOutputReverse) 00426 || (pstcConfig->enFrtPeakOddMatchEvenMatchOddChRtStatus > RtOutputReverse) 00427 || (pstcConfig->enFrtPeakOddMatchEvenNotMatchOddChRtStatus > RtOutputReverse) 00428 || (pstcConfig->enFrtPeakOddNotMatchEvenMatchOddChRtStatus > RtOutputReverse) 00429 || (pstcConfig->enFrtPeakOddNotMatchEvenNotMatchOddChRtStatus > RtOutputReverse) 00430 || (pstcConfig->enFrtDownOddMatchEvenMatchOddChRtStatus > RtOutputReverse) 00431 || (pstcConfig->enFrtDownOddMatchEvenNotMatchOddChRtStatus > RtOutputReverse) 00432 || (pstcConfig->enFrtDownOddNotMatchEvenMatchOddChRtStatus > RtOutputReverse) 00433 || (pstcConfig->enIopFlagWhenFrtZeroOddMatch > IopFlagSet) 00434 || (pstcConfig->enIopFlagWhenFrtUpCntOddMatch > IopFlagSet) 00435 || (pstcConfig->enIopFlagWhenFrtPeakOddMatch > IopFlagSet) 00436 || (pstcConfig->enIopFlagWhenFrtDownCntOddMatch > IopFlagSet) ) 00437 { 00438 return ErrorInvalidParameter ; 00439 } 00440 00441 pu32OCSE1 = (volatile uint32_t*)((volatile uint8_t*)pstcOcu + 0x28UL + OddCh*4); 00442 *pu32OCSE1 = 0; 00443 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enFrtZeroOddMatchEvenMatchOddChRtStatus << 26); 00444 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enFrtZeroOddMatchEvenNotMatchOddChRtStatus << 10); 00445 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enFrtZeroOddNotMatchEvenMatchOddChRtStatus << 30); 00446 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enFrtZeroOddNotMatchEvenNotMatchOddChRtStatus << 14); 00447 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enFrtUpCntOddMatchEvenMatchOddChRtStatus << 24); 00448 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enFrtUpCntOddMatchEvenNotMatchOddChRtStatus << 8); 00449 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enFrtUpCntOddNotMatchEvenMatchOddChRtStatus << 18); 00450 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enFrtPeakOddMatchEvenMatchOddChRtStatus << 22); 00451 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enFrtPeakOddMatchEvenNotMatchOddChRtStatus << 6) ; 00452 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enFrtPeakOddNotMatchEvenMatchOddChRtStatus << 28); 00453 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enFrtPeakOddNotMatchEvenNotMatchOddChRtStatus << 12); 00454 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enFrtDownOddMatchEvenMatchOddChRtStatus << 20); 00455 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enFrtDownOddMatchEvenNotMatchOddChRtStatus << 4); 00456 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enFrtDownOddNotMatchEvenMatchOddChRtStatus << 16); 00457 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enIopFlagWhenFrtZeroOddMatch << 3); 00458 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enIopFlagWhenFrtUpCntOddMatch << 2); 00459 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enIopFlagWhenFrtPeakOddMatch << 1); 00460 *pu32OCSE1 |= (uint32_t)((uint32_t)pstcConfig->enIopFlagWhenFrtDownCntOddMatch << 0); 00461 00462 return Ok; 00463 } 00464 00481 en_result_t Mft_Ocu_EnableOperation(volatile stc_mftn_ocu_t* pstcOcu, uint8_t u8Ch) 00482 { 00483 volatile stc_mft_ocu_ocsa10_field_t* pstcOCSA; 00484 00485 // Check for NULL pointer 00486 if ( (pstcOcu == NULL) 00487 || (u8Ch >= MFT_OCU_MAXCH)) 00488 { 00489 return ErrorInvalidParameter ; 00490 } 00491 00492 //Get pointer of current channel OCU register address 00493 pstcOCSA = (volatile stc_mft_ocu_ocsa10_field_t*)((volatile uint8_t*)pstcOcu + 0x18UL + (u8Ch/2)*4); 00494 00495 //set register 00496 if(0 == (u8Ch%2)) //channel 0,2,4 00497 { 00498 pstcOCSA->CST0 = 1; 00499 } 00500 else //channel 1,3,5 00501 { 00502 pstcOCSA->CST1 = 1; 00503 } 00504 00505 return Ok; 00506 } 00507 00524 en_result_t Mft_Ocu_DisableOperation(volatile stc_mftn_ocu_t* pstcOcu, uint8_t u8Ch) 00525 { 00526 volatile stc_mft_ocu_ocsa10_field_t* pstcOCSA; 00527 00528 // Check for NULL pointer 00529 if ( (pstcOcu == NULL) 00530 || (u8Ch >= MFT_OCU_MAXCH)) 00531 { 00532 return ErrorInvalidParameter ; 00533 } 00534 00535 //Get pointer of current channel OCU register address 00536 pstcOCSA = (volatile stc_mft_ocu_ocsa10_field_t*)((volatile uint8_t*)pstcOcu + 0x18UL + (u8Ch/2)*4); 00537 00538 //set register 00539 if(0 == (u8Ch%2)) //channel 0,2,4 00540 { 00541 pstcOCSA->CST0 = 0; 00542 } 00543 else //channel 1,3,5 00544 { 00545 pstcOCSA->CST1 = 0; 00546 } 00547 00548 return Ok; 00549 } 00550 00551 #if (PDL_INTERRUPT_ENABLE_MFT0_OCU == PDL_ON) || \ 00552 (PDL_INTERRUPT_ENABLE_MFT1_OCU == PDL_ON) || \ 00553 (PDL_INTERRUPT_ENABLE_MFT2_OCU == PDL_ON) 00554 00571 en_result_t Mft_Ocu_EnableInt(volatile stc_mftn_ocu_t* pstcOcu, 00572 uint8_t u8Ch, func_ptr_t pfnCallback) 00573 { 00574 stc_mft_ocu_intern_data_t* pstcOcuInternData; 00575 volatile stc_mft_ocu_ocsa10_field_t* pstcOCSA; 00576 func_ptr_t* fnCallback; 00577 // Check for NULL pointer 00578 if ( (pstcOcu == NULL) 00579 || (u8Ch >= MFT_OCU_MAXCH)) 00580 { 00581 return ErrorInvalidParameter ; 00582 } 00583 00584 // Get pointer to internal data structure ... 00585 pstcOcuInternData = MftGetInternDataPtr( pstcOcu ) ; 00586 00587 //Get pointer of current channel OCU register address 00588 pstcOCSA = (volatile stc_mft_ocu_ocsa10_field_t*)((volatile uint8_t*)pstcOcu + 0x18UL + (u8Ch/2)*4); 00589 00590 //set register 00591 if(0 == (u8Ch%2)) //channel 0,2,4 00592 { 00593 pstcOCSA->IOE0 = 1; 00594 } 00595 else //channel 1,3,5 00596 { 00597 pstcOCSA->IOE1 = 1; 00598 } 00599 00600 //set callback function 00601 fnCallback = (func_ptr_t*)((uint8_t*)&(pstcOcuInternData->pfnOcu0Callback) 00602 + (sizeof(func_ptr_t) * u8Ch)); 00603 *fnCallback = pfnCallback; 00604 00605 Mft_Ocu_InitIrq(pstcOcu); 00606 00607 return Ok; 00608 } 00609 00626 en_result_t Mft_Ocu_DisableInt(volatile stc_mftn_ocu_t* pstcOcu,uint8_t u8Ch) 00627 { 00628 stc_mft_ocu_intern_data_t* pstcOcuInternData; 00629 volatile stc_mft_ocu_ocsa10_field_t* pstcOCSA; 00630 00631 // Check for NULL pointer 00632 if ( (pstcOcu == NULL) 00633 || (u8Ch >= MFT_OCU_MAXCH)) 00634 { 00635 return ErrorInvalidParameter ; 00636 } 00637 00638 // Get pointer to internal data structure ... 00639 pstcOcuInternData = MftGetInternDataPtr( pstcOcu ) ; 00640 00641 //Get pointer of current channel OCU register address 00642 pstcOCSA = (volatile stc_mft_ocu_ocsa10_field_t*)((volatile uint8_t*)pstcOcu + 0x18UL + (u8Ch/2)*4); 00643 pstcOcuInternData = pstcOcuInternData + (sizeof(pstcOcuInternData)) * u8Ch; 00644 00645 //set register 00646 if(0 == (u8Ch%2)) //channel 0,2,4 00647 { 00648 pstcOCSA->IOE0 = 0; 00649 } 00650 else //channel 1,3,5 00651 { 00652 pstcOCSA->IOE1 = 0; 00653 } 00654 00655 //set callback function 00656 pstcOcuInternData = NULL; 00657 00658 Mft_Ocu_DeInitIrq(pstcOcu); 00659 00660 return Ok; 00661 } 00662 00663 #endif 00664 00678 en_int_flag_t Mft_Ocu_GetIntFlag(volatile stc_mftn_ocu_t* pstcOcu, uint8_t u8Ch) 00679 { 00680 volatile stc_mft_ocu_ocsa10_field_t* pstcOCSA; 00681 en_int_flag_t retval = PdlClr; 00682 00683 //Get pointer of current channel OCU register address 00684 pstcOCSA = (volatile stc_mft_ocu_ocsa10_field_t*)((volatile uint8_t*)pstcOcu + 0x18UL + (u8Ch/2)*4); 00685 00686 //set return value 00687 if(0 == (u8Ch%2)) //channel 0,2,4 00688 { 00689 (pstcOCSA->IOP0 == 1) ? (retval = PdlSet) : (retval = PdlClr); 00690 } 00691 else //channel 1,3,5 00692 { 00693 (pstcOCSA->IOP1 == 1) ? (retval = PdlSet) : (retval = PdlClr); 00694 } 00695 00696 return retval; 00697 } 00698 00715 en_result_t Mft_Ocu_ClrIntFlag(volatile stc_mftn_ocu_t* pstcOcu, uint8_t u8Ch) 00716 { 00717 volatile stc_mft_ocu_ocsa10_field_t* pstcOCSA; 00718 00719 // Check for NULL pointer 00720 if ( (pstcOcu == NULL) 00721 || (u8Ch >= MFT_OCU_MAXCH)) 00722 { 00723 return ErrorInvalidParameter ; 00724 } 00725 00726 //Get pointer of current channel OCU register address 00727 pstcOCSA = (volatile stc_mft_ocu_ocsa10_field_t*)((volatile uint8_t*)pstcOcu + 0x18UL + (u8Ch/2)*4); 00728 00729 //clear register 00730 if(0 == (u8Ch%2)) //channel 0,2,4 00731 { 00732 pstcOCSA->IOP0 = 0; 00733 } 00734 else //channel 1,3,5 00735 { 00736 pstcOCSA->IOP1 = 0; 00737 } 00738 00739 return Ok; 00740 } 00741 00755 en_ocu_rt_out_state_t Mft_Ocu_GetRtPinLevel(volatile stc_mftn_ocu_t* pstcOcu, 00756 uint8_t u8Ch) 00757 { 00758 volatile stc_mft_ocu_ocsb10_field_t* pstcOCSB; 00759 en_ocu_rt_out_state_t enLevel = RtLowLevel; 00760 00761 // Get the OCSB address 00762 pstcOCSB = (volatile stc_mft_ocu_ocsb10_field_t*)((volatile uint8_t*)pstcOcu + 0x19UL + (u8Ch/2)*4); 00763 if((u8Ch%2) == 0) 00764 { 00765 (pstcOCSB->OTD0 == 1) ? (enLevel = RtHighLevel) : (enLevel = RtLowLevel); 00766 } 00767 else 00768 { 00769 (pstcOCSB->OTD1 == 1) ? (enLevel = RtHighLevel) : (enLevel = RtLowLevel); 00770 } 00771 00772 return enLevel; 00773 } 00774 00793 en_result_t Mft_Ocu_WriteOccp(volatile stc_mftn_ocu_t* pstcOcu, 00794 uint8_t u8Ch, uint16_t u16Occp) 00795 { 00796 volatile uint16_t* p16OCCP; 00797 00798 // Check for NULL pointer 00799 if ( (pstcOcu == NULL) 00800 || (u8Ch >= MFT_OCU_MAXCH)) 00801 { 00802 return ErrorInvalidParameter ; 00803 } 00804 //Get pointer of current channel OCU register address 00805 p16OCCP = (volatile uint16_t*)((volatile uint8_t*)pstcOcu + 0x02 + u8Ch*4); 00806 00807 //set register 00808 *p16OCCP = u16Occp; 00809 00810 return Ok; 00811 } 00812 00825 uint16_t Mft_Ocu_ReadOccp(volatile stc_mftn_ocu_t* pstcOcu, uint8_t u8Ch) 00826 { 00827 volatile uint16_t* p16OCCP; 00828 00829 // Check for NULL pointer 00830 if ( (pstcOcu == NULL) 00831 || (u8Ch >= MFT_OCU_MAXCH)) 00832 { 00833 return 0 ; 00834 } 00835 //Get pointer of current channel OCU register address 00836 p16OCCP = (volatile uint16_t*)((volatile uint8_t*)pstcOcu + 0x02 + u8Ch*4); 00837 00838 return (uint16_t)((*p16OCCP) & 0xFFFFu); 00839 } 00840 00842 00843 #endif // #if (defined(PDL_PERIPHERAL_$$X_ACTIVE)) 00844 00845 /******************************************************************************/ 00846 /* EOF (not truncated) */ 00847 /******************************************************************************/