S32 SDK
flexio_hal.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2014 - 2016, Freescale Semiconductor, Inc.
3  * Copyright 2016 NXP
4  * All rights reserved.
5  *
6  * THIS SOFTWARE IS PROVIDED BY NXP "AS IS" AND ANY EXPRESSED OR
7  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
8  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
9  * IN NO EVENT SHALL NXP OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
10  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
11  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
12  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
13  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
14  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
15  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
16  * THE POSSIBILITY OF SUCH DAMAGE.
17  */
18 
19 #ifndef FLEXIO_HAL_H
20 #define FLEXIO_HAL_H
21 
22 #include <stdbool.h>
23 #include "device_registers.h"
24 
69  /*******************************************************************************
70  * Definitions
71  ******************************************************************************/
72 
76 typedef enum
77 {
81 
85 typedef enum
86 {
90 
94 typedef enum
95 {
101 
105 typedef enum
106 {
113 
117 typedef enum
118 {
122 
126 typedef enum
127 {
133 
137 typedef enum
138 {
142 
146 typedef enum
147 {
151 
155 typedef enum
156 {
162 
166 typedef enum
167 {
173 
177 typedef enum
178 {
184 
188 typedef enum
189 {
197 
201 typedef enum
202 {
211 
215 typedef enum
216 {
226 
230 typedef enum
231 {
237 
241 typedef enum
242 {
247 
251 typedef enum
252 {
258 
262 typedef enum
263 {
267 
271 typedef struct
272 {
273  uint8_t majorNumber;
274  uint8_t minorNumber;
275  uint16_t featureNumber;
277 
278 
279 /*******************************************************************************
280  * API
281  ******************************************************************************/
287 #if defined(__cplusplus)
288 extern "C" {
289 #endif
290 
291 
301 static inline void FLEXIO_HAL_GetVersion(const FLEXIO_Type *baseAddr, flexio_version_info_t *versionInfo)
302 {
303  uint32_t tmp = baseAddr->VERID;
304  versionInfo->majorNumber = (uint8_t)((tmp & FLEXIO_VERID_MAJOR_MASK) >> FLEXIO_VERID_MAJOR_SHIFT);
305  versionInfo->minorNumber = (uint8_t)((tmp & FLEXIO_VERID_MINOR_MASK) >> FLEXIO_VERID_MINOR_SHIFT);
306  versionInfo->featureNumber = (uint16_t)((tmp & FLEXIO_VERID_FEATURE_MASK) >> FLEXIO_VERID_FEATURE_SHIFT);
307  return;
308 }
309 
310 
320 static inline uint8_t FLEXIO_HAL_GetTriggerNum(const FLEXIO_Type *baseAddr)
321 {
322  uint32_t tmp = baseAddr->PARAM;
324  return (uint8_t)tmp;
325 }
326 
327 
337 static inline uint8_t FLEXIO_HAL_GetPinNum(const FLEXIO_Type *baseAddr)
338 {
339  uint32_t tmp = baseAddr->PARAM;
341  return (uint8_t)tmp;
342 }
343 
344 
354 static inline uint8_t FLEXIO_HAL_GetTimerNum(const FLEXIO_Type *baseAddr)
355 {
356  uint32_t tmp = baseAddr->PARAM;
358  return (uint8_t)tmp;
359 }
360 
361 
371 static inline uint8_t FLEXIO_HAL_GetShifterNum(const FLEXIO_Type *baseAddr)
372 {
373  uint32_t tmp = baseAddr->PARAM;
375  return (uint8_t)tmp;
376 }
377 
378 
388 static inline bool FLEXIO_HAL_GetDozeMode(const FLEXIO_Type *baseAddr)
389 {
390  uint32_t regValue = (uint32_t)baseAddr->CTRL;
391  regValue = (regValue & FLEXIO_CTRL_DOZEN_MASK) >> FLEXIO_CTRL_DOZEN_SHIFT;
392  return (bool)regValue;
393 }
394 
395 
405 static inline void FLEXIO_HAL_SetDozeMode(FLEXIO_Type *baseAddr, bool enable)
406 {
407  uint32_t regValue = (uint32_t)baseAddr->CTRL;
408  regValue &= (uint32_t)(~(FLEXIO_CTRL_DOZEN_MASK));
409  regValue |= FLEXIO_CTRL_DOZEN(enable);
410  baseAddr->CTRL = (uint32_t)regValue;
411 }
412 
413 
423 static inline bool FLEXIO_HAL_GetDebugMode(const FLEXIO_Type *baseAddr)
424 {
425  uint32_t regValue = (uint32_t)baseAddr->CTRL;
426  regValue = (regValue & FLEXIO_CTRL_DBGE_MASK) >> FLEXIO_CTRL_DBGE_SHIFT;
427  return (bool)regValue;
428 }
429 
430 
440 static inline void FLEXIO_HAL_SetDebugMode(FLEXIO_Type *baseAddr, bool enable)
441 {
442  uint32_t regValue = (uint32_t)baseAddr->CTRL;
443  regValue &= (uint32_t)(~(FLEXIO_CTRL_DBGE_MASK));
444  regValue |= FLEXIO_CTRL_DBGE(enable);
445  baseAddr->CTRL = (uint32_t)regValue;
446 }
447 
448 
460 static inline bool FLEXIO_HAL_GetFastAccess(const FLEXIO_Type *baseAddr)
461 {
462  uint32_t regValue = (uint32_t)baseAddr->CTRL;
463  regValue = (regValue & FLEXIO_CTRL_FASTACC_MASK) >> FLEXIO_CTRL_FASTACC_SHIFT;
464  return (bool)regValue;
465 }
466 
467 
479 static inline void FLEXIO_HAL_SetFastAccess(FLEXIO_Type *baseAddr, bool enable)
480 {
481  uint32_t regValue = (uint32_t)baseAddr->CTRL;
482  regValue &= (uint32_t)(~(FLEXIO_CTRL_FASTACC_MASK));
483  regValue |= FLEXIO_CTRL_FASTACC(enable);
484  baseAddr->CTRL = (uint32_t)regValue;
485 }
486 
487 
497 static inline bool FLEXIO_HAL_GetSoftwareReset(const FLEXIO_Type *baseAddr)
498 {
499  uint32_t regValue = (uint32_t)baseAddr->CTRL;
500  regValue = (regValue & FLEXIO_CTRL_SWRST_MASK) >> FLEXIO_CTRL_SWRST_SHIFT;
501  return (bool)regValue;
502 }
503 
504 
516 static inline void FLEXIO_HAL_SetSoftwareReset(FLEXIO_Type *baseAddr, bool enable)
517 {
518  uint32_t regValue = (uint32_t)baseAddr->CTRL;
519  regValue &= (uint32_t)(~(FLEXIO_CTRL_SWRST_MASK));
520  regValue |= FLEXIO_CTRL_SWRST(enable);
521  baseAddr->CTRL = (uint32_t)regValue;
522 }
523 
524 
534 static inline bool FLEXIO_HAL_GetEnable(const FLEXIO_Type *baseAddr)
535 {
536  uint32_t regValue = (uint32_t)baseAddr->CTRL;
537  regValue = (regValue & FLEXIO_CTRL_FLEXEN_MASK) >> FLEXIO_CTRL_FLEXEN_SHIFT;
538  return (bool)regValue;
539 }
540 
541 
551 static inline void FLEXIO_HAL_SetEnable(FLEXIO_Type *baseAddr, bool enable)
552 {
553  uint32_t regValue = (uint32_t)baseAddr->CTRL;
554  regValue &= (uint32_t)(~(FLEXIO_CTRL_FLEXEN_MASK));
555  regValue |= FLEXIO_CTRL_FLEXEN(enable);
556  baseAddr->CTRL = (uint32_t)regValue;
557 }
558 
559 
570 static inline uint8_t FLEXIO_HAL_GetPinData(const FLEXIO_Type *baseAddr)
571 {
572  uint32_t tmp = baseAddr->PIN;
573  tmp = (tmp & FLEXIO_PIN_PDI_MASK) >> FLEXIO_PIN_PDI_SHIFT;
574  return (uint8_t)tmp;
575 }
576 
577 
593 static inline bool FLEXIO_HAL_GetShifterStatus(const FLEXIO_Type *baseAddr, uint8_t shifter)
594 {
595  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
596 
597  uint32_t regValue = (uint32_t)baseAddr->SHIFTSTAT;
598  regValue = (regValue >> shifter) & 1U;
599  return (bool)regValue;
600 }
601 
602 
619 static inline uint32_t FLEXIO_HAL_GetAllShifterStatus(const FLEXIO_Type *baseAddr)
620 {
621  return baseAddr->SHIFTSTAT;
622 }
623 
624 
635 static inline void FLEXIO_HAL_ClearShifterStatus(FLEXIO_Type *baseAddr, uint8_t shifter)
636 {
637  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
638 
639  baseAddr->SHIFTSTAT = 1UL << shifter;
640 }
641 
642 
658 static inline bool FLEXIO_HAL_GetShifterErrorStatus(const FLEXIO_Type *baseAddr, uint8_t shifter)
659 {
660  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
661 
662  uint32_t regValue = (uint32_t)baseAddr->SHIFTERR;
663  regValue = (regValue >> shifter) & 1U;
664  return (bool)regValue;
665 }
666 
667 
684 static inline uint32_t FLEXIO_HAL_GetAllShifterErrorStatus(const FLEXIO_Type *baseAddr)
685 {
686  return baseAddr->SHIFTERR;
687 }
688 
689 
699 static inline void FLEXIO_HAL_ClearShifterErrorStatus(FLEXIO_Type *baseAddr, uint8_t shifter)
700 {
701  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
702 
703  baseAddr->SHIFTERR = 1UL << shifter;
704 }
705 
706 
724 static inline bool FLEXIO_HAL_GetTimerStatus(const FLEXIO_Type *baseAddr, uint8_t timer)
725 {
726  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
727 
728  uint32_t regValue = (uint32_t)baseAddr->TIMSTAT;
729  regValue = (regValue >> timer) & 1U;
730  return (bool)regValue;
731 }
732 
733 
752 static inline uint32_t FLEXIO_HAL_GetAllTimerStatus(const FLEXIO_Type *baseAddr)
753 {
754  return baseAddr->TIMSTAT;
755 }
756 
757 
767 static inline void FLEXIO_HAL_ClearTimerStatus(FLEXIO_Type *baseAddr, uint8_t timer)
768 {
769  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
770 
771  baseAddr->TIMSTAT = 1UL << timer;
772 }
773 
774 
785 static inline bool FLEXIO_HAL_GetShifterInterrupt(const FLEXIO_Type *baseAddr, uint8_t interruptNo)
786 {
787  DEV_ASSERT(interruptNo < FLEXIO_HAL_GetShifterNum(baseAddr));
788 
789  uint32_t regValue = (uint32_t)baseAddr->SHIFTSIEN;
790  regValue = (regValue >> interruptNo) & 1U;
791  return (bool)regValue;
792 }
793 
794 
806 static inline uint32_t FLEXIO_HAL_GetAllShifterInterrupt(const FLEXIO_Type *baseAddr)
807 {
808  return baseAddr->SHIFTSIEN;
809 }
810 
811 
823 static inline void FLEXIO_HAL_SetShifterInterrupt(FLEXIO_Type *baseAddr, uint8_t interruptMask, bool enable)
824 {
825  uint32_t tmp;
826 
827  DEV_ASSERT((interruptMask & ~((1U << FLEXIO_HAL_GetShifterNum(baseAddr)) - 1U)) == 0U);
828 
829  tmp = baseAddr->SHIFTSIEN;
830 
831  if (enable == true)
832  {
833  tmp |= interruptMask;
834  }
835  else
836  {
837  tmp &= ~interruptMask;
838  }
839  baseAddr->SHIFTSIEN = tmp;
840 }
841 
842 
853 static inline bool FLEXIO_HAL_GetShifterErrorInterrupt(const FLEXIO_Type *baseAddr, uint8_t interruptNo)
854 {
855  DEV_ASSERT(interruptNo < FLEXIO_HAL_GetShifterNum(baseAddr));
856 
857  uint32_t regValue = (uint32_t)baseAddr->SHIFTEIEN;
858  regValue = (regValue >> interruptNo) & 1U;
859  return (bool)regValue;
860 }
861 
862 
874 static inline uint32_t FLEXIO_HAL_GetAllShifterErrorInterrupt(const FLEXIO_Type *baseAddr)
875 {
876  return baseAddr->SHIFTEIEN;
877 }
878 
879 
891 static inline void FLEXIO_HAL_SetShifterErrorInterrupt(FLEXIO_Type *baseAddr, uint8_t interruptMask, bool enable)
892 {
893  uint32_t tmp;
894 
895  DEV_ASSERT((interruptMask & ~((1U << FLEXIO_HAL_GetShifterNum(baseAddr)) - 1U)) == 0U);
896 
897  tmp = baseAddr->SHIFTEIEN;
898 
899  if (enable == true)
900  {
901  tmp |= interruptMask;
902  }
903  else
904  {
905  tmp &= ~interruptMask;
906  }
907  baseAddr->SHIFTEIEN = tmp;
908 }
909 
910 
921 static inline bool FLEXIO_HAL_GetTimerInterrupt(const FLEXIO_Type *baseAddr, uint8_t interruptNo)
922 {
923  DEV_ASSERT(interruptNo < FLEXIO_HAL_GetTimerNum(baseAddr));
924 
925  uint32_t regValue = (uint32_t)baseAddr->TIMIEN;
926  regValue = (regValue >> interruptNo) & 1U;
927  return (bool)regValue;
928 }
929 
930 
942 static inline uint32_t FLEXIO_HAL_GetAllTimerInterrupt(const FLEXIO_Type *baseAddr)
943 {
944  return baseAddr->TIMIEN;
945 }
946 
947 
959 static inline void FLEXIO_HAL_SetTimerInterrupt(FLEXIO_Type *baseAddr, uint8_t interruptMask, bool enable)
960 {
961  uint32_t tmp;
962 
963  DEV_ASSERT((interruptMask & ~((1U << FLEXIO_HAL_GetTimerNum(baseAddr)) - 1U)) == 0U);
964 
965  tmp = baseAddr->TIMIEN;
966 
967  if (enable == true)
968  {
969  tmp |= interruptMask;
970  }
971  else
972  {
973  tmp &= ~interruptMask;
974  }
975  baseAddr->TIMIEN = tmp;
976 }
977 
978 
989 static inline bool FLEXIO_HAL_GetShifterDMARequest(const FLEXIO_Type *baseAddr, uint8_t requestNo)
990 {
991  DEV_ASSERT(requestNo < FLEXIO_HAL_GetShifterNum(baseAddr));
992 
993  uint32_t regValue = (uint32_t)baseAddr->SHIFTSDEN;
994  regValue = (regValue >> requestNo) & 1U;
995  return (bool)regValue;
996 }
997 
998 
1010 static inline void FLEXIO_HAL_SetShifterDMARequest(FLEXIO_Type *baseAddr, uint8_t requestMask, bool enable)
1011 {
1012  uint32_t tmp;
1013 
1014  DEV_ASSERT((requestMask & ~((1U << FLEXIO_HAL_GetShifterNum(baseAddr)) - 1U)) == 0U);
1015 
1016  tmp = baseAddr->SHIFTSDEN;
1017 
1018  if (enable == true)
1019  {
1020  tmp |= requestMask;
1021  }
1022  else
1023  {
1024  tmp &= ~requestMask;
1025  }
1026  baseAddr->SHIFTSDEN = tmp;
1027 }
1028 
1029 
1041 static inline void FLEXIO_HAL_GetShifterTimer(const FLEXIO_Type *baseAddr,
1042  uint8_t shifter,
1043  uint8_t *timer,
1044  flexio_timer_polarity_t *polarity)
1045 {
1046  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1047 
1048  uint32_t tmp = baseAddr->SHIFTCTL[shifter];
1049  *timer = (uint8_t)((tmp & FLEXIO_SHIFTCTL_TIMSEL_MASK) >> FLEXIO_SHIFTCTL_TIMSEL_SHIFT);
1051  *polarity = (flexio_timer_polarity_t)tmp;
1052 }
1053 
1054 
1066 static inline void FLEXIO_HAL_SetShifterTimer(FLEXIO_Type *baseAddr,
1067  uint8_t shifter,
1068  uint8_t timer,
1069  flexio_timer_polarity_t polarity)
1070 {
1071  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1072  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1073 
1074  uint32_t tmp = baseAddr->SHIFTCTL[shifter];
1075  tmp &= ~(FLEXIO_SHIFTCTL_TIMSEL_MASK);
1076  tmp |= FLEXIO_SHIFTCTL_TIMSEL(timer);
1077  tmp &= ~(FLEXIO_SHIFTCTL_TIMPOL_MASK);
1078  tmp |= FLEXIO_SHIFTCTL_TIMPOL(polarity);
1079  baseAddr->SHIFTCTL[shifter] = tmp;
1080 }
1081 
1082 
1096 static inline void FLEXIO_HAL_GetShifterPin(const FLEXIO_Type *baseAddr,
1097  uint8_t shifter,
1098  uint8_t *pin,
1099  flexio_pin_polarity_t *polarity,
1100  flexio_pin_config_t *config)
1101 {
1102  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1103 
1104  uint32_t tmp = baseAddr->SHIFTCTL[shifter];
1105  *pin = (uint8_t)((tmp & FLEXIO_SHIFTCTL_PINSEL_MASK) >> FLEXIO_SHIFTCTL_PINSEL_SHIFT);
1108 }
1109 
1110 
1124 static inline void FLEXIO_HAL_SetShifterPin(FLEXIO_Type *baseAddr,
1125  uint8_t shifter,
1126  uint8_t pin,
1127  flexio_pin_polarity_t polarity,
1128  flexio_pin_config_t config)
1129 {
1130  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1131  DEV_ASSERT(pin < FLEXIO_HAL_GetPinNum(baseAddr));
1132 
1133  uint32_t tmp = baseAddr->SHIFTCTL[shifter];
1134  tmp &= ~(FLEXIO_SHIFTCTL_PINSEL_MASK);
1135  tmp |= FLEXIO_SHIFTCTL_PINSEL(pin);
1136  tmp &= ~(FLEXIO_SHIFTCTL_PINPOL_MASK);
1137  tmp |= FLEXIO_SHIFTCTL_PINPOL(polarity);
1138  tmp &= ~(FLEXIO_SHIFTCTL_PINCFG_MASK);
1139  tmp |= FLEXIO_SHIFTCTL_PINCFG(config);
1140  baseAddr->SHIFTCTL[shifter] = tmp;
1141 }
1142 
1143 
1155 static inline void FLEXIO_HAL_SetShifterPinConfig(FLEXIO_Type *baseAddr,
1156  uint8_t shifter,
1157  flexio_pin_config_t config)
1158 {
1159  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1160 
1161  uint32_t tmp = baseAddr->SHIFTCTL[shifter];
1162  tmp &= ~(FLEXIO_SHIFTCTL_PINCFG_MASK);
1163  tmp |= FLEXIO_SHIFTCTL_PINCFG(config);
1164  baseAddr->SHIFTCTL[shifter] = tmp;
1165 }
1166 
1167 
1178 static inline flexio_shifter_mode_t FLEXIO_HAL_GetShifterMode(const FLEXIO_Type *baseAddr, uint8_t shifter)
1179 {
1180  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1181 
1182  uint32_t tmp = baseAddr->SHIFTCTL[shifter];
1184  return (flexio_shifter_mode_t)tmp;
1185 }
1186 
1187 
1198 static inline void FLEXIO_HAL_SetShifterMode(FLEXIO_Type *baseAddr,
1199  uint8_t shifter,
1200  flexio_shifter_mode_t mode)
1201 {
1202  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1203 
1204  uint32_t tmp = baseAddr->SHIFTCTL[shifter];
1205  tmp &= ~(FLEXIO_SHIFTCTL_SMOD_MASK);
1206  tmp |= FLEXIO_SHIFTCTL_SMOD(mode);
1207  baseAddr->SHIFTCTL[shifter] = tmp;
1208 }
1209 
1210 
1228 static inline void FLEXIO_HAL_SetShifterControl(FLEXIO_Type *baseAddr,
1229  uint8_t shifter,
1230  flexio_shifter_mode_t mode,
1231  uint8_t pin,
1232  flexio_pin_polarity_t pinPolarity,
1233  flexio_pin_config_t pinConfig,
1234  uint8_t timer,
1235  flexio_timer_polarity_t timerPolarity)
1236 {
1237  baseAddr->SHIFTCTL[shifter] = FLEXIO_SHIFTCTL_SMOD(mode)
1238  | FLEXIO_SHIFTCTL_PINPOL(pinPolarity)
1239  | FLEXIO_SHIFTCTL_PINSEL(pin)
1240  | FLEXIO_SHIFTCTL_PINCFG(pinConfig)
1241  | FLEXIO_SHIFTCTL_TIMPOL(timerPolarity)
1242  | FLEXIO_SHIFTCTL_TIMSEL(timer);
1243 }
1244 
1245 
1256 static inline flexio_shifter_source_t FLEXIO_HAL_GetShifterInputSource(const FLEXIO_Type *baseAddr, uint8_t shifter)
1257 {
1258  uint32_t tmp;
1259  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1260 
1261  tmp = baseAddr->SHIFTCFG[shifter];
1263  return (flexio_shifter_source_t)tmp;
1264 }
1265 
1266 
1277 static inline void FLEXIO_HAL_SetShifterInputSource(FLEXIO_Type *baseAddr,
1278  uint8_t shifter,
1279  flexio_shifter_source_t source)
1280 {
1281  uint32_t tmp;
1282  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1283 
1284  tmp = baseAddr->SHIFTCFG[shifter];
1285  tmp &= ~(FLEXIO_SHIFTCFG_INSRC_MASK);
1286  tmp |= FLEXIO_SHIFTCFG_INSRC(source);
1287  baseAddr->SHIFTCFG[shifter] = tmp;
1288 }
1289 
1290 
1302 static inline flexio_shifter_stop_t FLEXIO_HAL_GetShifterStopBit(const FLEXIO_Type *baseAddr, uint8_t shifter)
1303 {
1304  uint32_t tmp;
1305  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1306 
1307  tmp = baseAddr->SHIFTCFG[shifter];
1309  return (flexio_shifter_stop_t)tmp;
1310 }
1311 
1312 
1324 static inline void FLEXIO_HAL_SetShifterStopBit(FLEXIO_Type *baseAddr, uint8_t shifter, flexio_shifter_stop_t stop)
1325 {
1326  uint32_t tmp;
1327  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1328 
1329  tmp = baseAddr->SHIFTCFG[shifter];
1330  tmp &= ~(FLEXIO_SHIFTCFG_SSTOP_MASK);
1331  tmp |= FLEXIO_SHIFTCFG_SSTOP(stop);
1332  baseAddr->SHIFTCFG[shifter] = tmp;
1333 }
1334 
1335 
1347 static inline flexio_shifter_start_t FLEXIO_HAL_GetShifterStartBit(const FLEXIO_Type *baseAddr, uint8_t shifter)
1348 {
1349  uint32_t tmp;
1350  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1351 
1352  tmp = baseAddr->SHIFTCFG[shifter];
1354  return (flexio_shifter_start_t)tmp;
1355 }
1356 
1357 
1369 static inline void FLEXIO_HAL_SetShifterStartBit(FLEXIO_Type *baseAddr,
1370  uint8_t shifter,
1371  flexio_shifter_start_t start)
1372 {
1373  uint32_t tmp;
1374  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1375 
1376  tmp = baseAddr->SHIFTCFG[shifter];
1377  tmp &= ~(FLEXIO_SHIFTCFG_SSTART_MASK);
1378  tmp |= FLEXIO_SHIFTCFG_SSTART(start);
1379  baseAddr->SHIFTCFG[shifter] = tmp;
1380 }
1381 
1382 
1396 static inline void FLEXIO_HAL_SetShifterConfig(FLEXIO_Type *baseAddr,
1397  uint8_t shifter,
1398  flexio_shifter_start_t start,
1399  flexio_shifter_stop_t stop,
1400  flexio_shifter_source_t source)
1401 {
1402  baseAddr->SHIFTCFG[shifter] = FLEXIO_SHIFTCFG_SSTART(start)
1403  | FLEXIO_SHIFTCFG_SSTOP(stop)
1404  | FLEXIO_SHIFTCFG_INSRC(source);
1405 }
1406 
1407 
1421 static inline uint32_t FLEXIO_HAL_ReadShifterBuffer(const FLEXIO_Type *baseAddr,
1422  uint8_t shifter,
1424 {
1425  uint32_t data;
1426 
1427  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1428 
1429  switch (mode)
1430  {
1432  data = baseAddr->SHIFTBUF[shifter];
1433  break;
1435  data = baseAddr->SHIFTBUFBIS[shifter];
1436  break;
1438  data = baseAddr->SHIFTBUFBYS[shifter];
1439  break;
1441  data = baseAddr->SHIFTBUFBBS[shifter];
1442  break;
1443  default:
1444  /* bad read mode */
1445  data = 0U;
1446  break;
1447  }
1448  return data;
1449 }
1450 
1451 
1465 static inline void FLEXIO_HAL_WriteShifterBuffer(FLEXIO_Type *baseAddr,
1466  uint8_t shifter,
1467  uint32_t value,
1469 {
1470  DEV_ASSERT(shifter < FLEXIO_HAL_GetShifterNum(baseAddr));
1471 
1472  switch (mode)
1473  {
1475  baseAddr->SHIFTBUF[shifter] = value;
1476  break;
1478  baseAddr->SHIFTBUFBIS[shifter] = value;
1479  break;
1481  baseAddr->SHIFTBUFBYS[shifter] = value;
1482  break;
1484  baseAddr->SHIFTBUFBBS[shifter] = value;
1485  break;
1486  default:
1487  /* bad write mode */
1488  break;
1489  }
1490 }
1491 
1492 
1506 static inline void FLEXIO_HAL_GetTimerTrigger(const FLEXIO_Type *baseAddr,
1507  uint8_t timer,
1508  uint8_t *trigger,
1509  flexio_trigger_polarity_t *polarity,
1510  flexio_trigger_source_t *source)
1511 {
1512  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1513 
1514  uint32_t tmp = baseAddr->TIMCTL[timer];
1515  *trigger = (uint8_t)((tmp & FLEXIO_TIMCTL_TRGSEL_MASK) >> FLEXIO_TIMCTL_TRGSEL_SHIFT);
1518 }
1519 
1520 
1539 static inline void FLEXIO_HAL_SetTimerTrigger(FLEXIO_Type *baseAddr,
1540  uint8_t timer,
1541  uint8_t trigger,
1542  flexio_trigger_polarity_t polarity,
1543  flexio_trigger_source_t source)
1544 {
1545  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1546 
1547  uint32_t tmp = baseAddr->TIMCTL[timer];
1548  tmp &= ~(FLEXIO_TIMCTL_TRGSEL_MASK);
1549  tmp |= FLEXIO_TIMCTL_TRGSEL(trigger);
1550  tmp &= ~(FLEXIO_TIMCTL_TRGPOL_MASK);
1551  tmp |= FLEXIO_TIMCTL_TRGPOL(polarity);
1552  tmp &= ~(FLEXIO_TIMCTL_TRGSRC_MASK);
1553  tmp |= FLEXIO_TIMCTL_TRGSRC(source);
1554  baseAddr->TIMCTL[timer] = tmp;
1555 }
1556 
1557 
1571 static inline void FLEXIO_HAL_GetTimerPin(const FLEXIO_Type *baseAddr,
1572  uint8_t timer,
1573  uint8_t *pin,
1574  flexio_pin_polarity_t *polarity,
1575  flexio_pin_config_t *config)
1576 {
1577  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1578 
1579  uint32_t tmp = baseAddr->TIMCTL[timer];
1580  *pin = (uint8_t)((tmp & FLEXIO_TIMCTL_PINSEL_MASK) >> FLEXIO_TIMCTL_PINSEL_SHIFT);
1583 }
1584 
1585 
1599 static inline void FLEXIO_HAL_SetTimerPin(FLEXIO_Type *baseAddr,
1600  uint8_t timer,
1601  uint8_t pin,
1602  flexio_pin_polarity_t polarity,
1603  flexio_pin_config_t config)
1604 {
1605  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1606  DEV_ASSERT(pin < FLEXIO_HAL_GetPinNum(baseAddr));
1607 
1608  uint32_t tmp = baseAddr->TIMCTL[timer];
1609  tmp &= ~(FLEXIO_TIMCTL_PINSEL_MASK);
1610  tmp |= FLEXIO_TIMCTL_PINSEL(pin);
1611  tmp &= ~(FLEXIO_TIMCTL_PINPOL_MASK);
1612  tmp |= FLEXIO_TIMCTL_PINPOL(polarity);
1613  tmp &= ~(FLEXIO_TIMCTL_PINCFG_MASK);
1614  tmp |= FLEXIO_TIMCTL_PINCFG(config);
1615  baseAddr->TIMCTL[timer] = tmp;
1616 }
1617 
1618 
1629 static inline flexio_timer_mode_t FLEXIO_HAL_GetTimerMode(const FLEXIO_Type *baseAddr, uint8_t timer)
1630 {
1631  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1632 
1633  uint32_t tmp = baseAddr->TIMCTL[timer];
1635  return (flexio_timer_mode_t)tmp;
1636 }
1637 
1638 
1658 static inline void FLEXIO_HAL_SetTimerMode(FLEXIO_Type *baseAddr,
1659  uint8_t timer,
1660  flexio_timer_mode_t mode)
1661 {
1662  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1663 
1664  uint32_t tmp = baseAddr->TIMCTL[timer];
1665  tmp &= ~(FLEXIO_TIMCTL_TIMOD_MASK);
1666  tmp |= FLEXIO_TIMCTL_TIMOD(mode);
1667  baseAddr->TIMCTL[timer] = tmp;
1668 }
1669 
1670 
1689 static inline void FLEXIO_HAL_SetTimerControl(FLEXIO_Type *baseAddr,
1690  uint8_t timer,
1691  uint8_t trigger,
1692  flexio_trigger_polarity_t triggerPolarity,
1693  flexio_trigger_source_t triggerSource,
1694  uint8_t pin,
1695  flexio_pin_polarity_t pinPolarity,
1696  flexio_pin_config_t pinConfig,
1697  flexio_timer_mode_t mode)
1698 {
1699  baseAddr->TIMCTL[timer] = FLEXIO_TIMCTL_TIMOD(mode)
1700  | FLEXIO_TIMCTL_PINSEL(pin)
1701  | FLEXIO_TIMCTL_PINPOL(pinPolarity)
1702  | FLEXIO_TIMCTL_PINCFG(pinConfig)
1703  | FLEXIO_TIMCTL_TRGSRC(triggerSource)
1704  | FLEXIO_TIMCTL_TRGPOL(triggerPolarity)
1705  | FLEXIO_TIMCTL_TRGSEL(trigger);
1706 }
1707 
1708 
1709 
1720 static inline flexio_timer_output_t FLEXIO_HAL_GetTimerInitialOutput(const FLEXIO_Type *baseAddr, uint8_t timer)
1721 {
1722  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1723 
1724  uint32_t tmp = baseAddr->TIMCFG[timer];
1726  return (flexio_timer_output_t)tmp;
1727 }
1728 
1729 
1741 static inline void FLEXIO_HAL_SetTimerInitialOutput(FLEXIO_Type *baseAddr,
1742  uint8_t timer,
1743  flexio_timer_output_t output)
1744 {
1745  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1746 
1747  uint32_t tmp = baseAddr->TIMCFG[timer];
1748  tmp &= ~(FLEXIO_TIMCFG_TIMOUT_MASK);
1749  tmp |= FLEXIO_TIMCFG_TIMOUT(output);
1750  baseAddr->TIMCFG[timer] = tmp;
1751 }
1752 
1753 
1765 static inline flexio_timer_decrement_t FLEXIO_HAL_GetTimerDecrement(const FLEXIO_Type *baseAddr, uint8_t timer)
1766 {
1767  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1768 
1769  uint32_t tmp = baseAddr->TIMCFG[timer];
1771  return (flexio_timer_decrement_t)tmp;
1772 }
1773 
1774 
1787 static inline void FLEXIO_HAL_SetTimerDecrement(FLEXIO_Type *baseAddr,
1788  uint8_t timer,
1789  flexio_timer_decrement_t decrement)
1790 {
1791  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1792 
1793  uint32_t tmp = baseAddr->TIMCFG[timer];
1794  tmp &= ~(FLEXIO_TIMCFG_TIMDEC_MASK);
1795  tmp |= FLEXIO_TIMCFG_TIMDEC(decrement);
1796  baseAddr->TIMCFG[timer] = tmp;
1797 }
1798 
1799 
1811 static inline flexio_timer_reset_t FLEXIO_HAL_GetTimerReset(const FLEXIO_Type *baseAddr, uint8_t timer)
1812 {
1813  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1814 
1815  uint32_t tmp = baseAddr->TIMCFG[timer];
1817  return (flexio_timer_reset_t)tmp;
1818 }
1819 
1820 
1835 static inline void FLEXIO_HAL_SetTimerReset(FLEXIO_Type *baseAddr,
1836  uint8_t timer,
1837  flexio_timer_reset_t reset)
1838 {
1839  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1840 
1841  uint32_t tmp = baseAddr->TIMCFG[timer];
1842  tmp &= ~(FLEXIO_TIMCFG_TIMRST_MASK);
1843  tmp |= FLEXIO_TIMCFG_TIMRST(reset);
1844  baseAddr->TIMCFG[timer] = tmp;
1845 }
1846 
1847 
1859 static inline flexio_timer_disable_t FLEXIO_HAL_GetTimerDisable(const FLEXIO_Type *baseAddr, uint8_t timer)
1860 {
1861  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1862 
1863  uint32_t tmp = baseAddr->TIMCFG[timer];
1865  return (flexio_timer_disable_t)tmp;
1866 }
1867 
1868 
1880 static inline void FLEXIO_HAL_SetTimerDisable(FLEXIO_Type *baseAddr,
1881  uint8_t timer,
1882  flexio_timer_disable_t disable)
1883 {
1884  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1885 
1886  uint32_t tmp = baseAddr->TIMCFG[timer];
1887  tmp &= ~(FLEXIO_TIMCFG_TIMDIS_MASK);
1888  tmp |= FLEXIO_TIMCFG_TIMDIS(disable);
1889  baseAddr->TIMCFG[timer] = tmp;
1890 }
1891 
1892 
1905 static inline flexio_timer_enable_t FLEXIO_HAL_GetTimerEnable(const FLEXIO_Type *baseAddr, uint8_t timer)
1906 {
1907  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1908 
1909  uint32_t tmp = baseAddr->TIMCFG[timer];
1911  return (flexio_timer_enable_t)tmp;
1912 }
1913 
1914 
1927 static inline void FLEXIO_HAL_SetTimerEnable(FLEXIO_Type *baseAddr,
1928  uint8_t timer,
1929  flexio_timer_enable_t enable)
1930 {
1931  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1932 
1933  uint32_t tmp = baseAddr->TIMCFG[timer];
1934  tmp &= ~(FLEXIO_TIMCFG_TIMENA_MASK);
1935  tmp |= FLEXIO_TIMCFG_TIMENA(enable);
1936  baseAddr->TIMCFG[timer] = tmp;
1937 }
1938 
1939 
1955 static inline flexio_timer_stop_t FLEXIO_HAL_GetTimerStop(const FLEXIO_Type *baseAddr, uint8_t timer)
1956 {
1957  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1958 
1959  uint32_t tmp = baseAddr->TIMCFG[timer];
1961  return (flexio_timer_stop_t)tmp;
1962 }
1963 
1964 
1980 static inline void FLEXIO_HAL_SetTimerStop(FLEXIO_Type *baseAddr,
1981  uint8_t timer,
1982  flexio_timer_stop_t stop)
1983 {
1984  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
1985 
1986  uint32_t tmp = baseAddr->TIMCFG[timer];
1987  tmp &= ~(FLEXIO_TIMCFG_TSTOP_MASK);
1988  tmp |= FLEXIO_TIMCFG_TSTOP(stop);
1989  baseAddr->TIMCFG[timer] = tmp;
1990 }
1991 
1992 
2006 static inline flexio_timer_start_t FLEXIO_HAL_GetTimerStart(const FLEXIO_Type *baseAddr, uint8_t timer)
2007 {
2008  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
2009 
2010  uint32_t regValue = (uint32_t)baseAddr->TIMCFG[timer];
2011  regValue = (regValue & FLEXIO_TIMCFG_TSTART_MASK) >> FLEXIO_TIMCFG_TSTART_SHIFT;
2012  return (flexio_timer_start_t)regValue;
2013 }
2014 
2015 
2029 static inline void FLEXIO_HAL_SetTimerStart(FLEXIO_Type *baseAddr,
2030  uint8_t timer,
2031  flexio_timer_start_t start)
2032 {
2033  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
2034 
2035  uint32_t regValue = (uint32_t)baseAddr->TIMCFG[timer];
2036  regValue &= (uint32_t)(~(FLEXIO_TIMCFG_TSTART_MASK));
2037  regValue |= FLEXIO_TIMCFG_TSTART(start);
2038  baseAddr->TIMCFG[timer] = (uint32_t)regValue;
2039 }
2040 
2041 
2060 static inline void FLEXIO_HAL_SetTimerConfig(FLEXIO_Type *baseAddr,
2061  uint8_t timer,
2062  flexio_timer_start_t start,
2063  flexio_timer_stop_t stop,
2064  flexio_timer_enable_t enable,
2065  flexio_timer_disable_t disable,
2066  flexio_timer_reset_t reset,
2067  flexio_timer_decrement_t decrement,
2068  flexio_timer_output_t output)
2069 {
2070 
2071  baseAddr->TIMCFG[timer] = FLEXIO_TIMCFG_TSTART(start)
2072  | FLEXIO_TIMCFG_TSTOP(stop)
2073  | FLEXIO_TIMCFG_TIMENA(enable)
2074  | FLEXIO_TIMCFG_TIMDIS(disable)
2075  | FLEXIO_TIMCFG_TIMRST(reset)
2076  | FLEXIO_TIMCFG_TIMDEC(decrement)
2077  | FLEXIO_TIMCFG_TIMOUT(output);
2078 }
2079 
2080 
2091 static inline uint16_t FLEXIO_HAL_GetTimerCompare(const FLEXIO_Type *baseAddr, uint8_t timer)
2092 {
2093  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
2094 
2095  return (uint16_t)(baseAddr->TIMCMP[timer]);
2096 }
2097 
2098 
2118 static inline void FLEXIO_HAL_SetTimerCompare(FLEXIO_Type *baseAddr,
2119  uint8_t timer,
2120  uint16_t value)
2121 {
2122  DEV_ASSERT(timer < FLEXIO_HAL_GetTimerNum(baseAddr));
2123 
2124  baseAddr->TIMCMP[timer] = (uint32_t)value;
2125 }
2126 
2127 
2136 void FLEXIO_HAL_Init(FLEXIO_Type *baseAddr);
2137 
2138 
2140 #if defined(__cplusplus)
2141 }
2142 #endif
2143 
2146 #endif /* FLEXIO_HAL_H */
2147 /*******************************************************************************
2148  * EOF
2149  ******************************************************************************/
flexio_timer_enable_t
Timer disable options Implements : flexio_timer_enable_t_Class.
Definition: flexio_hal.h:215
__I uint32_t PARAM
Definition: S32K144.h:3474
flexio_timer_output_t
Timer initial output options Implements : flexio_timer_output_t_Class.
Definition: flexio_hal.h:166
static void FLEXIO_HAL_SetShifterPin(FLEXIO_Type *baseAddr, uint8_t shifter, uint8_t pin, flexio_pin_polarity_t polarity, flexio_pin_config_t config)
Assigns the specified pin to the specified shifter.
Definition: flexio_hal.h:1124
#define FLEXIO_TIMCTL_TIMOD_MASK
Definition: S32K144.h:3685
#define FLEXIO_SHIFTCTL_PINCFG_SHIFT
Definition: S32K144.h:3640
__IO uint32_t SHIFTBUF[FLEXIO_SHIFTBUF_COUNT]
Definition: S32K144.h:3491
static void FLEXIO_HAL_SetShifterInterrupt(FLEXIO_Type *baseAddr, uint8_t interruptMask, bool enable)
Enables or disables the shifter interrupts.
Definition: flexio_hal.h:823
static void FLEXIO_HAL_SetShifterMode(FLEXIO_Type *baseAddr, uint8_t shifter, flexio_shifter_mode_t mode)
Sets the mode of the specified shifter.
Definition: flexio_hal.h:1198
flexio_timer_polarity_t
Shift clock polarity options Implements : flexio_timer_polarity_t_Class.
Definition: flexio_hal.h:76
static uint16_t FLEXIO_HAL_GetTimerCompare(const FLEXIO_Type *baseAddr, uint8_t timer)
Returns the compare value of the specified timer.
Definition: flexio_hal.h:2091
#define FLEXIO_TIMCTL_TRGPOL_SHIFT
Definition: S32K144.h:3706
#define FLEXIO_TIMCFG_TIMRST_SHIFT
Definition: S32K144.h:3731
static flexio_timer_mode_t FLEXIO_HAL_GetTimerMode(const FLEXIO_Type *baseAddr, uint8_t timer)
Returns the mode of the specified timer.
Definition: flexio_hal.h:1629
static void FLEXIO_HAL_GetShifterPin(const FLEXIO_Type *baseAddr, uint8_t shifter, uint8_t *pin, flexio_pin_polarity_t *polarity, flexio_pin_config_t *config)
Returns the pin currently assigned to the specified shifter, and its configured settings.
Definition: flexio_hal.h:1096
__IO uint32_t SHIFTSTAT
Definition: S32K144.h:3477
static void FLEXIO_HAL_SetTimerDisable(FLEXIO_Type *baseAddr, uint8_t timer, flexio_timer_disable_t disable)
Configures the disable condition for the specified timer.
Definition: flexio_hal.h:1880
static void FLEXIO_HAL_SetTimerControl(FLEXIO_Type *baseAddr, uint8_t timer, uint8_t trigger, flexio_trigger_polarity_t triggerPolarity, flexio_trigger_source_t triggerSource, uint8_t pin, flexio_pin_polarity_t pinPolarity, flexio_pin_config_t pinConfig, flexio_timer_mode_t mode)
Sets all control settings for specified timer.
Definition: flexio_hal.h:1689
static uint8_t FLEXIO_HAL_GetPinData(const FLEXIO_Type *baseAddr)
Returns the current input data read from the FlexIO pins.
Definition: flexio_hal.h:570
#define FLEXIO_TIMCFG_TSTART_MASK
Definition: S32K144.h:3714
#define FLEXIO_PARAM_PIN_MASK
Definition: S32K144.h:3557
static flexio_timer_disable_t FLEXIO_HAL_GetTimerDisable(const FLEXIO_Type *baseAddr, uint8_t timer)
Returns the disable configuration of the specified timer.
Definition: flexio_hal.h:1859
#define FLEXIO_TIMCFG_TIMENA_SHIFT
Definition: S32K144.h:3723
__IO uint32_t TIMCMP[FLEXIO_TIMCMP_COUNT]
Definition: S32K144.h:3503
#define FLEXIO_PARAM_TIMER_SHIFT
Definition: S32K144.h:3554
static void FLEXIO_HAL_SetTimerStop(FLEXIO_Type *baseAddr, uint8_t timer, flexio_timer_stop_t stop)
Configures the stop bit for the specified timer.
Definition: flexio_hal.h:1980
static bool FLEXIO_HAL_GetTimerStatus(const FLEXIO_Type *baseAddr, uint8_t timer)
Returns the current status of the specified timer.
Definition: flexio_hal.h:724
#define FLEXIO_TIMCFG_TSTOP(x)
Definition: S32K144.h:3721
#define FLEXIO_TIMCTL_PINSEL_MASK
Definition: S32K144.h:3693
static void FLEXIO_HAL_SetTimerMode(FLEXIO_Type *baseAddr, uint8_t timer, flexio_timer_mode_t mode)
Sets the mode of the specified timer.
Definition: flexio_hal.h:1658
#define FLEXIO_TIMCTL_TRGSEL(x)
Definition: S32K144.h:3712
#define FLEXIO_TIMCTL_TIMOD_SHIFT
Definition: S32K144.h:3686
__IO uint32_t CTRL
Definition: S32K144.h:3475
flexio_timer_disable_t
Timer disable options Implements : flexio_timer_disable_t_Class.
Definition: flexio_hal.h:201
#define FLEXIO_TIMCFG_TSTART_SHIFT
Definition: S32K144.h:3715
#define FLEXIO_TIMCFG_TSTOP_MASK
Definition: S32K144.h:3718
#define FLEXIO_TIMCFG_TIMDIS(x)
Definition: S32K144.h:3729
static void FLEXIO_HAL_SetTimerStart(FLEXIO_Type *baseAddr, uint8_t timer, flexio_timer_start_t start)
Configures the start bit for the specified timer.
Definition: flexio_hal.h:2029
__I uint32_t PIN
Definition: S32K144.h:3476
static bool FLEXIO_HAL_GetDozeMode(const FLEXIO_Type *baseAddr)
Returns the current doze mode setting.
Definition: flexio_hal.h:388
flexio_pin_config_t
Pin configuration options Implements : flexio_pin_config_t_Class.
Definition: flexio_hal.h:94
#define FLEXIO_CTRL_FLEXEN_SHIFT
Definition: S32K144.h:3567
static flexio_timer_start_t FLEXIO_HAL_GetTimerStart(const FLEXIO_Type *baseAddr, uint8_t timer)
Returns the start bit configuration of the specified timer.
Definition: flexio_hal.h:2006
static uint32_t FLEXIO_HAL_GetAllShifterStatus(const FLEXIO_Type *baseAddr)
Returns the current status flags for all shifters.
Definition: flexio_hal.h:619
static void FLEXIO_HAL_SetShifterInputSource(FLEXIO_Type *baseAddr, uint8_t shifter, flexio_shifter_source_t source)
Configures the input source of the specified shifter.
Definition: flexio_hal.h:1277
static uint8_t FLEXIO_HAL_GetTimerNum(const FLEXIO_Type *baseAddr)
Returns the number of timers of the FlexIO module.
Definition: flexio_hal.h:354
static uint8_t FLEXIO_HAL_GetShifterNum(const FLEXIO_Type *baseAddr)
Returns the number of shifters of the FlexIO module.
Definition: flexio_hal.h:371
flexio_shifter_start_t
Timer start bit options - for Transmit, Receive or Match Store modes only Implements : flexio_shifter...
Definition: flexio_hal.h:251
static void FLEXIO_HAL_SetFastAccess(FLEXIO_Type *baseAddr, bool enable)
Configure the FlexIO fast access feature.
Definition: flexio_hal.h:479
#define FLEXIO_TIMCTL_PINCFG(x)
Definition: S32K144.h:3700
static void FLEXIO_HAL_WriteShifterBuffer(FLEXIO_Type *baseAddr, uint8_t shifter, uint32_t value, flexio_shifter_buffer_mode_t mode)
Writes a value in the specified shifter buffer.
Definition: flexio_hal.h:1465
#define FLEXIO_SHIFTCTL_PINCFG(x)
Definition: S32K144.h:3642
static void FLEXIO_HAL_SetTimerPin(FLEXIO_Type *baseAddr, uint8_t timer, uint8_t pin, flexio_pin_polarity_t polarity, flexio_pin_config_t config)
Configures the pin for the specified timer.
Definition: flexio_hal.h:1599
__IO uint32_t SHIFTBUFBBS[FLEXIO_SHIFTBUFBBS_COUNT]
Definition: S32K144.h:3497
#define FLEXIO_SHIFTCTL_SMOD_MASK
Definition: S32K144.h:3627
static bool FLEXIO_HAL_GetDebugMode(const FLEXIO_Type *baseAddr)
Returns the current debug mode setting.
Definition: flexio_hal.h:423
static void FLEXIO_HAL_SetShifterPinConfig(FLEXIO_Type *baseAddr, uint8_t shifter, flexio_pin_config_t config)
Configures the pin assigned to the specified shifter.
Definition: flexio_hal.h:1155
#define FLEXIO_SHIFTCTL_TIMSEL_MASK
Definition: S32K144.h:3647
#define FLEXIO_VERID_FEATURE_MASK
Definition: S32K144.h:3536
#define FLEXIO_PIN_PDI_MASK
Definition: S32K144.h:3587
#define FLEXIO_TIMCTL_TRGSEL_SHIFT
Definition: S32K144.h:3710
static void FLEXIO_HAL_SetShifterStartBit(FLEXIO_Type *baseAddr, uint8_t shifter, flexio_shifter_start_t start)
Configures the start bit of the specified shifter.
Definition: flexio_hal.h:1369
static void FLEXIO_HAL_ClearTimerStatus(FLEXIO_Type *baseAddr, uint8_t timer)
Clears the status of the specified timer.
Definition: flexio_hal.h:767
#define FLEXIO_SHIFTCTL_TIMPOL(x)
Definition: S32K144.h:3646
#define FLEXIO_CTRL_SWRST(x)
Definition: S32K144.h:3573
#define FLEXIO_CTRL_DOZEN_SHIFT
Definition: S32K144.h:3583
#define FLEXIO_VERID_MINOR_MASK
Definition: S32K144.h:3540
#define FLEXIO_SHIFTCTL_TIMPOL_SHIFT
Definition: S32K144.h:3644
static void FLEXIO_HAL_SetSoftwareReset(FLEXIO_Type *baseAddr, bool enable)
Set/clear the FlexIO reset command.
Definition: flexio_hal.h:516
#define FLEXIO_SHIFTCTL_TIMSEL(x)
Definition: S32K144.h:3650
static void FLEXIO_HAL_SetTimerInterrupt(FLEXIO_Type *baseAddr, uint8_t interruptMask, bool enable)
Enables or disables the timer interrupts.
Definition: flexio_hal.h:959
static flexio_shifter_stop_t FLEXIO_HAL_GetShifterStopBit(const FLEXIO_Type *baseAddr, uint8_t shifter)
Returns the stop bit configuration for the specified shifter.
Definition: flexio_hal.h:1302
static void FLEXIO_HAL_SetShifterConfig(FLEXIO_Type *baseAddr, uint8_t shifter, flexio_shifter_start_t start, flexio_shifter_stop_t stop, flexio_shifter_source_t source)
Sets all configuration settings for specified shifter.
Definition: flexio_hal.h:1396
#define FLEXIO_CTRL_FLEXEN_MASK
Definition: S32K144.h:3566
#define FLEXIO_TIMCFG_TIMENA_MASK
Definition: S32K144.h:3722
#define FLEXIO_SHIFTCTL_PINSEL(x)
Definition: S32K144.h:3638
static uint32_t FLEXIO_HAL_ReadShifterBuffer(const FLEXIO_Type *baseAddr, uint8_t shifter, flexio_shifter_buffer_mode_t mode)
Reads the value from the specified shifter buffer.
Definition: flexio_hal.h:1421
#define FLEXIO_SHIFTCTL_PINSEL_SHIFT
Definition: S32K144.h:3636
static bool FLEXIO_HAL_GetShifterDMARequest(const FLEXIO_Type *baseAddr, uint8_t requestNo)
Returns the current status of the shifter DMA requests.
Definition: flexio_hal.h:989
#define FLEXIO_TIMCTL_TIMOD(x)
Definition: S32K144.h:3688
flexio_timer_start_t
Timer start bit options Implements : flexio_timer_start_t_Class.
Definition: flexio_hal.h:262
#define DEV_ASSERT(x)
Definition: devassert.h:78
FlexIO module version number Implements : flexio_version_info_t_Class.
Definition: flexio_hal.h:271
#define FLEXIO_PARAM_SHIFTER_SHIFT
Definition: S32K144.h:3550
#define FLEXIO_CTRL_FASTACC_SHIFT
Definition: S32K144.h:3575
#define FLEXIO_TIMCTL_TRGSRC_SHIFT
Definition: S32K144.h:3702
#define FLEXIO_SHIFTCTL_PINPOL(x)
Definition: S32K144.h:3634
static void FLEXIO_HAL_GetTimerTrigger(const FLEXIO_Type *baseAddr, uint8_t timer, uint8_t *trigger, flexio_trigger_polarity_t *polarity, flexio_trigger_source_t *source)
Returns the currently configured trigger for the specified timer.
Definition: flexio_hal.h:1506
static bool FLEXIO_HAL_GetTimerInterrupt(const FLEXIO_Type *baseAddr, uint8_t interruptNo)
Returns the current status of the timer interrupts.
Definition: flexio_hal.h:921
#define FLEXIO_TIMCTL_PINSEL_SHIFT
Definition: S32K144.h:3694
static void FLEXIO_HAL_SetDebugMode(FLEXIO_Type *baseAddr, bool enable)
Set the FlexIO module behavior in debug mode.
Definition: flexio_hal.h:440
static void FLEXIO_HAL_SetTimerInitialOutput(FLEXIO_Type *baseAddr, uint8_t timer, flexio_timer_output_t output)
Configures the initial output of the specified timer.
Definition: flexio_hal.h:1741
static uint8_t FLEXIO_HAL_GetPinNum(const FLEXIO_Type *baseAddr)
Returns the number of pins of the FlexIO module.
Definition: flexio_hal.h:337
__IO uint32_t SHIFTBUFBIS[FLEXIO_SHIFTBUFBIS_COUNT]
Definition: S32K144.h:3493
#define FLEXIO_TIMCFG_TIMDIS_MASK
Definition: S32K144.h:3726
static void FLEXIO_HAL_SetShifterControl(FLEXIO_Type *baseAddr, uint8_t shifter, flexio_shifter_mode_t mode, uint8_t pin, flexio_pin_polarity_t pinPolarity, flexio_pin_config_t pinConfig, uint8_t timer, flexio_timer_polarity_t timerPolarity)
Sets all control settings for the specified shifter.
Definition: flexio_hal.h:1228
#define FLEXIO_SHIFTCFG_INSRC_MASK
Definition: S32K144.h:3660
#define FLEXIO_CTRL_DBGE_MASK
Definition: S32K144.h:3578
#define FLEXIO_CTRL_FASTACC_MASK
Definition: S32K144.h:3574
#define FLEXIO_VERID_FEATURE_SHIFT
Definition: S32K144.h:3537
static uint32_t FLEXIO_HAL_GetAllTimerStatus(const FLEXIO_Type *baseAddr)
Returns the current status of all timers.
Definition: flexio_hal.h:752
static void FLEXIO_HAL_GetShifterTimer(const FLEXIO_Type *baseAddr, uint8_t shifter, uint8_t *timer, flexio_timer_polarity_t *polarity)
Returns the timer currently assigned to control the specified shifter.
Definition: flexio_hal.h:1041
#define FLEXIO_TIMCFG_TIMDEC_SHIFT
Definition: S32K144.h:3735
#define FLEXIO_CTRL_FLEXEN(x)
Definition: S32K144.h:3569
#define FLEXIO_SHIFTCFG_SSTART(x)
Definition: S32K144.h:3655
#define FLEXIO_TIMCTL_PINCFG_MASK
Definition: S32K144.h:3697
static uint32_t FLEXIO_HAL_GetAllShifterErrorStatus(const FLEXIO_Type *baseAddr)
Returns the current error status for all shifters.
Definition: flexio_hal.h:684
flexio_shifter_buffer_mode_t
Read/Write mode for shifter buffer Implements : flexio_shifter_buffer_mode_t_Class.
Definition: flexio_hal.h:126
static void FLEXIO_HAL_GetTimerPin(const FLEXIO_Type *baseAddr, uint8_t timer, uint8_t *pin, flexio_pin_polarity_t *polarity, flexio_pin_config_t *config)
Returns the currently configured pin for the specified timer.
Definition: flexio_hal.h:1571
static flexio_timer_decrement_t FLEXIO_HAL_GetTimerDecrement(const FLEXIO_Type *baseAddr, uint8_t timer)
Returns the decrement configuration of the specified timer.
Definition: flexio_hal.h:1765
#define FLEXIO_VERID_MAJOR_SHIFT
Definition: S32K144.h:3545
flexio_timer_decrement_t
Timer decrement options Implements : flexio_timer_decrement_t_Class.
Definition: flexio_hal.h:177
void FLEXIO_HAL_Init(FLEXIO_Type *baseAddr)
Initializes the FlexIO module to a known state.
Definition: flexio_hal.c:42
#define FLEXIO_VERID_MAJOR_MASK
Definition: S32K144.h:3544
#define FLEXIO_TIMCFG_TIMOUT_MASK
Definition: S32K144.h:3738
__IO uint32_t SHIFTBUFBYS[FLEXIO_SHIFTBUFBYS_COUNT]
Definition: S32K144.h:3495
#define FLEXIO_SHIFTCTL_SMOD(x)
Definition: S32K144.h:3630
__IO uint32_t SHIFTEIEN
Definition: S32K144.h:3482
#define FLEXIO_TIMCTL_PINPOL(x)
Definition: S32K144.h:3692
#define FLEXIO_SHIFTCTL_TIMSEL_SHIFT
Definition: S32K144.h:3648
static void FLEXIO_HAL_SetTimerCompare(FLEXIO_Type *baseAddr, uint8_t timer, uint16_t value)
Configures the compare value for the specified timer.
Definition: flexio_hal.h:2118
static void FLEXIO_HAL_SetTimerTrigger(FLEXIO_Type *baseAddr, uint8_t timer, uint8_t trigger, flexio_trigger_polarity_t polarity, flexio_trigger_source_t source)
Configures the trigger for the specified timer.
Definition: flexio_hal.h:1539
static uint32_t FLEXIO_HAL_GetAllShifterErrorInterrupt(const FLEXIO_Type *baseAddr)
Returns the current status of all the shifter error interrupts.
Definition: flexio_hal.h:874
static void FLEXIO_HAL_GetVersion(const FLEXIO_Type *baseAddr, flexio_version_info_t *versionInfo)
Reads the version of the FlexIO module.
Definition: flexio_hal.h:301
#define FLEXIO_TIMCTL_TRGSEL_MASK
Definition: S32K144.h:3709
static void FLEXIO_HAL_SetShifterTimer(FLEXIO_Type *baseAddr, uint8_t shifter, uint8_t timer, flexio_timer_polarity_t polarity)
Assigns the specified timer to control the specified shifter.
Definition: flexio_hal.h:1066
#define FLEXIO_TIMCFG_TIMDIS_SHIFT
Definition: S32K144.h:3727
static flexio_timer_enable_t FLEXIO_HAL_GetTimerEnable(const FLEXIO_Type *baseAddr, uint8_t timer)
Returns the enable condition configuration of the specified timer.
Definition: flexio_hal.h:1905
#define FLEXIO_SHIFTCFG_SSTOP(x)
Definition: S32K144.h:3659
static void FLEXIO_HAL_SetTimerReset(FLEXIO_Type *baseAddr, uint8_t timer, flexio_timer_reset_t reset)
Configures the reset condition for the specified timer.
Definition: flexio_hal.h:1835
#define FLEXIO_SHIFTCTL_PINPOL_SHIFT
Definition: S32K144.h:3632
static bool FLEXIO_HAL_GetShifterInterrupt(const FLEXIO_Type *baseAddr, uint8_t interruptNo)
Returns the current status of the shifter interrupts.
Definition: flexio_hal.h:785
static void FLEXIO_HAL_SetTimerConfig(FLEXIO_Type *baseAddr, uint8_t timer, flexio_timer_start_t start, flexio_timer_stop_t stop, flexio_timer_enable_t enable, flexio_timer_disable_t disable, flexio_timer_reset_t reset, flexio_timer_decrement_t decrement, flexio_timer_output_t output)
Sets all configuration settings for specified timer.
Definition: flexio_hal.h:2060
#define FLEXIO_SHIFTCTL_PINPOL_MASK
Definition: S32K144.h:3631
#define FLEXIO_SHIFTCTL_SMOD_SHIFT
Definition: S32K144.h:3628
#define FLEXIO_TIMCTL_PINPOL_SHIFT
Definition: S32K144.h:3690
#define FLEXIO_CTRL_SWRST_SHIFT
Definition: S32K144.h:3571
flexio_shifter_source_t
Shifter input source options Implements : flexio_shifter_source_t_Class.
Definition: flexio_hal.h:117
static void FLEXIO_HAL_SetTimerEnable(FLEXIO_Type *baseAddr, uint8_t timer, flexio_timer_enable_t enable)
Configures the enable condition for the specified timer.
Definition: flexio_hal.h:1927
#define FLEXIO_SHIFTCFG_SSTART_SHIFT
Definition: S32K144.h:3653
static void FLEXIO_HAL_SetTimerDecrement(FLEXIO_Type *baseAddr, uint8_t timer, flexio_timer_decrement_t decrement)
Configures the decrement condition for the specified timer.
Definition: flexio_hal.h:1787
#define FLEXIO_TIMCTL_PINPOL_MASK
Definition: S32K144.h:3689
static bool FLEXIO_HAL_GetShifterErrorInterrupt(const FLEXIO_Type *baseAddr, uint8_t interruptNo)
Returns the current status of the shifter error interrupts.
Definition: flexio_hal.h:853
#define FLEXIO_VERID_MINOR_SHIFT
Definition: S32K144.h:3541
#define FLEXIO_TIMCFG_TIMENA(x)
Definition: S32K144.h:3725
#define FLEXIO_CTRL_DOZEN(x)
Definition: S32K144.h:3585
__IO uint32_t SHIFTCFG[FLEXIO_SHIFTCFG_COUNT]
Definition: S32K144.h:3489
flexio_trigger_source_t
Trigger sources Implements : flexio_trigger_source_t_Class.
Definition: flexio_hal.h:146
#define FLEXIO_TIMCTL_PINSEL(x)
Definition: S32K144.h:3696
#define FLEXIO_PARAM_TIMER_MASK
Definition: S32K144.h:3553
static bool FLEXIO_HAL_GetEnable(const FLEXIO_Type *baseAddr)
Returns the current enable/disable setting of the FlexIO.
Definition: flexio_hal.h:534
#define FLEXIO_TIMCFG_TIMDEC(x)
Definition: S32K144.h:3737
#define FLEXIO_SHIFTCTL_PINCFG_MASK
Definition: S32K144.h:3639
flexio_pin_polarity_t
Pin polarity options Implements : flexio_pin_polarity_t_Class.
Definition: flexio_hal.h:85
__IO uint32_t SHIFTSIEN
Definition: S32K144.h:3481
flexio_shifter_stop_t
Timer stop bit options - for Transmit, Receive or Match Store modes only Implements : flexio_shifter_...
Definition: flexio_hal.h:241
static bool FLEXIO_HAL_GetSoftwareReset(const FLEXIO_Type *baseAddr)
Returns the current software reset state.
Definition: flexio_hal.h:497
#define FLEXIO_TIMCFG_TIMRST(x)
Definition: S32K144.h:3733
flexio_shifter_mode_t
Shifter mode options Implements : flexio_shifter_mode_t_Class.
Definition: flexio_hal.h:105
#define FLEXIO_SHIFTCFG_INSRC_SHIFT
Definition: S32K144.h:3661
static void FLEXIO_HAL_SetDozeMode(FLEXIO_Type *baseAddr, bool enable)
Set the FlexIO module behavior in doze mode.
Definition: flexio_hal.h:405
static bool FLEXIO_HAL_GetShifterStatus(const FLEXIO_Type *baseAddr, uint8_t shifter)
Returns the current status of the specified shifter.
Definition: flexio_hal.h:593
__IO uint32_t SHIFTCTL[FLEXIO_SHIFTCTL_COUNT]
Definition: S32K144.h:3487
static void FLEXIO_HAL_ClearShifterErrorStatus(FLEXIO_Type *baseAddr, uint8_t shifter)
Clears the error status of the specified shifter.
Definition: flexio_hal.h:699
#define FLEXIO_SHIFTCFG_SSTOP_MASK
Definition: S32K144.h:3656
#define FLEXIO_SHIFTCTL_PINSEL_MASK
Definition: S32K144.h:3635
#define FLEXIO_TIMCFG_TIMRST_MASK
Definition: S32K144.h:3730
__IO uint32_t SHIFTERR
Definition: S32K144.h:3478
#define FLEXIO_PARAM_TRIGGER_SHIFT
Definition: S32K144.h:3562
#define FLEXIO_TIMCTL_TRGPOL(x)
Definition: S32K144.h:3708
static void FLEXIO_HAL_SetShifterErrorInterrupt(FLEXIO_Type *baseAddr, uint8_t interruptMask, bool enable)
Enables or disables the shifter error interrupts.
Definition: flexio_hal.h:891
#define FLEXIO_TIMCFG_TSTART(x)
Definition: S32K144.h:3717
#define FLEXIO_TIMCFG_TIMDEC_MASK
Definition: S32K144.h:3734
__IO uint32_t TIMCTL[FLEXIO_TIMCTL_COUNT]
Definition: S32K144.h:3499
static bool FLEXIO_HAL_GetShifterErrorStatus(const FLEXIO_Type *baseAddr, uint8_t shifter)
Returns the current error status of the specified shifter.
Definition: flexio_hal.h:658
flexio_timer_mode_t
Timer mode options Implements : flexio_timer_mode_t_Class.
Definition: flexio_hal.h:155
#define FLEXIO_CTRL_DBGE(x)
Definition: S32K144.h:3581
#define FLEXIO_TIMCTL_TRGPOL_MASK
Definition: S32K144.h:3705
#define FLEXIO_TIMCTL_TRGSRC(x)
Definition: S32K144.h:3704
#define FLEXIO_TIMCFG_TSTOP_SHIFT
Definition: S32K144.h:3719
#define FLEXIO_CTRL_DBGE_SHIFT
Definition: S32K144.h:3579
#define FLEXIO_PARAM_PIN_SHIFT
Definition: S32K144.h:3558
__IO uint32_t TIMIEN
Definition: S32K144.h:3483
#define FLEXIO_PARAM_SHIFTER_MASK
Definition: S32K144.h:3549
#define FLEXIO_SHIFTCFG_INSRC(x)
Definition: S32K144.h:3663
static flexio_shifter_mode_t FLEXIO_HAL_GetShifterMode(const FLEXIO_Type *baseAddr, uint8_t shifter)
Returns the mode of the specified shifter.
Definition: flexio_hal.h:1178
flexio_timer_reset_t
Timer reset options Implements : flexio_timer_reset_t_Class.
Definition: flexio_hal.h:188
static flexio_timer_reset_t FLEXIO_HAL_GetTimerReset(const FLEXIO_Type *baseAddr, uint8_t timer)
Returns the reset configuration of the specified timer.
Definition: flexio_hal.h:1811
#define FLEXIO_SHIFTCFG_SSTART_MASK
Definition: S32K144.h:3652
__IO uint32_t TIMCFG[FLEXIO_TIMCFG_COUNT]
Definition: S32K144.h:3501
static void FLEXIO_HAL_SetShifterStopBit(FLEXIO_Type *baseAddr, uint8_t shifter, flexio_shifter_stop_t stop)
Configures the stop bit of the specified shifter.
Definition: flexio_hal.h:1324
flexio_trigger_polarity_t
Trigger polarity Implements : flexio_trigger_polarity_t_Class.
Definition: flexio_hal.h:137
__IO uint32_t TIMSTAT
Definition: S32K144.h:3479
__I uint32_t VERID
Definition: S32K144.h:3473
__IO uint32_t SHIFTSDEN
Definition: S32K144.h:3485
static flexio_timer_output_t FLEXIO_HAL_GetTimerInitialOutput(const FLEXIO_Type *baseAddr, uint8_t timer)
Returns the initial output configuration of the specified timer.
Definition: flexio_hal.h:1720
static flexio_shifter_source_t FLEXIO_HAL_GetShifterInputSource(const FLEXIO_Type *baseAddr, uint8_t shifter)
Returns the input source of the specified shifter.
Definition: flexio_hal.h:1256
#define FLEXIO_CTRL_DOZEN_MASK
Definition: S32K144.h:3582
static void FLEXIO_HAL_SetEnable(FLEXIO_Type *baseAddr, bool enable)
Enables of disables the FlexIO module.
Definition: flexio_hal.h:551
static flexio_timer_stop_t FLEXIO_HAL_GetTimerStop(const FLEXIO_Type *baseAddr, uint8_t timer)
Returns the stop bit configuration of the specified timer.
Definition: flexio_hal.h:1955
#define FLEXIO_CTRL_SWRST_MASK
Definition: S32K144.h:3570
#define FLEXIO_SHIFTCTL_TIMPOL_MASK
Definition: S32K144.h:3643
static uint32_t FLEXIO_HAL_GetAllShifterInterrupt(const FLEXIO_Type *baseAddr)
Returns the current status of all the shifter interrupts.
Definition: flexio_hal.h:806
#define FLEXIO_TIMCTL_TRGSRC_MASK
Definition: S32K144.h:3701
flexio_timer_stop_t
Timer stop bit options Implements : flexio_timer_stop_t_Class.
Definition: flexio_hal.h:230
static void FLEXIO_HAL_ClearShifterStatus(FLEXIO_Type *baseAddr, uint8_t shifter)
Clears the status of the specified shifter.
Definition: flexio_hal.h:635
static bool FLEXIO_HAL_GetFastAccess(const FLEXIO_Type *baseAddr)
Returns the current fast access setting.
Definition: flexio_hal.h:460
#define FLEXIO_PIN_PDI_SHIFT
Definition: S32K144.h:3588
#define FLEXIO_SHIFTCFG_SSTOP_SHIFT
Definition: S32K144.h:3657
static void FLEXIO_HAL_SetShifterDMARequest(FLEXIO_Type *baseAddr, uint8_t requestMask, bool enable)
Enables or disables the shifter DMA requests.
Definition: flexio_hal.h:1010
#define FLEXIO_PARAM_TRIGGER_MASK
Definition: S32K144.h:3561
#define FLEXIO_TIMCFG_TIMOUT_SHIFT
Definition: S32K144.h:3739
static uint8_t FLEXIO_HAL_GetTriggerNum(const FLEXIO_Type *baseAddr)
Returns the number of external triggers of the FlexIO module.
Definition: flexio_hal.h:320
static flexio_shifter_start_t FLEXIO_HAL_GetShifterStartBit(const FLEXIO_Type *baseAddr, uint8_t shifter)
Returns the start bit configuration for the specified shifter.
Definition: flexio_hal.h:1347
static uint32_t FLEXIO_HAL_GetAllTimerInterrupt(const FLEXIO_Type *baseAddr)
Returns the current status of all the timer interrupts.
Definition: flexio_hal.h:942
#define FLEXIO_CTRL_FASTACC(x)
Definition: S32K144.h:3577
#define FLEXIO_TIMCTL_PINCFG_SHIFT
Definition: S32K144.h:3698
#define FLEXIO_TIMCFG_TIMOUT(x)
Definition: S32K144.h:3741