Hilscher netX microcontroller driver  V0.0.5.0
Documentation of the netX driver package
netx_drv_dio.c
Go to the documentation of this file.
1 /*!************************************************************************/
25 #include "netx_drv.h"
26 #ifdef DRV_DIO_MODULE_ENABLED
27 #include <string.h>
28 
29 /*lint -save -e685 */
30 /*lint -save -e568 */
31 
71 DRV_DIO_HANDLE_T const s_tIODriver = { DRV_GPIO_DEVICE, DRV_PIO_DEVICE, DRV_MMIO_DEVICE, DRV_HIF_IO_DEVICE };
72 
76 DRV_CALLBACK_F s_afnIRQHandler[DRV_DIO_IRQ_COUNT] = { 0 };
77 
81 void* s_apIRQHandlerHandles[DRV_DIO_IRQ_COUNT] = { 0 };
82 
86 #ifndef DRV_HANDLE_CHECK_INACTIVE
87 #define DRV_HANDLE_CHECK(handle); \
88  if((handle).ptGPIODevice==0||(handle).ptMMIODevice==0||(handle).ptPIODevice==0){ \
89  return DRV_ERROR; \
90  }
91 #else
92 #define DRV_HANDLE_CHECK(handle) ;
93 #endif
94 
96 typedef enum
97 {
98  DRV_DIO_HIF_IRQ_MODE_LOW = 0x0u,
99  DRV_DIO_HIF_IRQ_MODE_HIGH = 0x1u,
100  DRV_DIO_HIF_IRQ_MODE_FALLING = 0x2u,
101  DRV_DIO_HIF_IRQ_MODE_RISING = 0x3u
102 } DRV_DIO_HIF_IRQ_MODE_E;
103 
113 __INLINE static void DRV_DIO_SetPIO(uint32_t ulChannel)
114 {
115  (void) DRV_IRQ_Disable();
116  s_tIODriver.ptPIODevice->pio_out |= ulChannel & DRV_DIO_LINE_MSK_PIO;
117  s_tIODriver.ptPIODevice->pio_oe |= ulChannel & DRV_DIO_LINE_MSK_PIO;
118  (void) DRV_IRQ_Enable();
119 }
120 
130 __INLINE static void DRV_DIO_ResetPIO(uint32_t ulChannel)
131 {
132  (void) DRV_IRQ_Disable();
133  s_tIODriver.ptPIODevice->pio_out &= ~(ulChannel & DRV_DIO_LINE_MSK_PIO );
134  s_tIODriver.ptPIODevice->pio_oe |= (ulChannel & DRV_DIO_LINE_MSK_PIO );
135  (void) DRV_IRQ_Enable();
136 }
137 
147 __INLINE static void DRV_DIO_ReadModePIO(uint32_t ulChannel)
148 {
149  (void) DRV_IRQ_Disable();
150  s_tIODriver.ptPIODevice->pio_out &= ~(ulChannel & DRV_DIO_LINE_MSK_PIO );
151  s_tIODriver.ptPIODevice->pio_oe &= ~(ulChannel & DRV_DIO_LINE_MSK_PIO );
152  (void) DRV_IRQ_Enable();
153 }
154 
164 __INLINE static void DRV_DIO_SetHIF(uint64_t ulChannel)
165 {
166  (void) DRV_IRQ_Disable();
167  ulChannel &= DRV_DIO_LINE_MSK_HIF;
168  s_tIODriver.ptHIFIODevice->hif_pio_out0 |= ulChannel;
169  s_tIODriver.ptHIFIODevice->hif_pio_oe0 |= ulChannel;
170  s_tIODriver.ptHIFIODevice->hif_pio_out1 |= (ulChannel >> 32);
171  s_tIODriver.ptHIFIODevice->hif_pio_oe1 |= (ulChannel >> 32);
172  (void) DRV_IRQ_Enable();
173 }
174 
184 __INLINE static void DRV_DIO_ResetHIF(uint64_t ulChannel)
185 {
186  (void) DRV_IRQ_Disable();
187  s_tIODriver.ptHIFIODevice->hif_pio_out0 &= ~ulChannel;
188  s_tIODriver.ptHIFIODevice->hif_pio_oe0 |= ulChannel;
189  s_tIODriver.ptHIFIODevice->hif_pio_out1 &= ~(ulChannel >> 32);
190  s_tIODriver.ptHIFIODevice->hif_pio_oe1 |= (ulChannel >> 32);
191  (void) DRV_IRQ_Enable();
192 }
193 
203 __INLINE static void DRV_DIO_ReadModeHIF(uint64_t ulChannel)
204 {
205  (void) DRV_IRQ_Disable();
206  s_tIODriver.ptHIFIODevice->hif_pio_out0 &= ~ulChannel;
207  s_tIODriver.ptHIFIODevice->hif_pio_oe0 &= ~ulChannel;
208  s_tIODriver.ptHIFIODevice->hif_pio_out1 &= ~(ulChannel >> 32);
209  s_tIODriver.ptHIFIODevice->hif_pio_oe1 &= ~(ulChannel >> 32);
210  (void) DRV_IRQ_Enable();
211 }
212 
222 __INLINE static void DRV_DIO_SetMMIO(uint32_t ulChannel)
223 {
224  (void) DRV_IRQ_Disable();
225  s_tIODriver.ptMMIODevice->mmio_pio_out_line_set_cfg0 = (ulChannel & DRV_DIO_LINE_MSK_MMIO );
226  s_tIODriver.ptMMIODevice->mmio_pio_oe_line_set_cfg0 = (ulChannel & DRV_DIO_LINE_MSK_MMIO );
227  (void) DRV_IRQ_Enable();
228 }
229 
239 __INLINE static void DRV_DIO_ResetMMIO(uint32_t ulChannel)
240 {
241  (void) DRV_IRQ_Disable();
242  s_tIODriver.ptMMIODevice->mmio_pio_out_line_reset_cfg0 = (ulChannel & DRV_DIO_LINE_MSK_MMIO );
243  s_tIODriver.ptMMIODevice->mmio_pio_oe_line_set_cfg0 = (ulChannel & DRV_DIO_LINE_MSK_MMIO );
244  (void) DRV_IRQ_Enable();
245 }
246 
256 __INLINE static void DRV_DIO_ReadModeMMIO(uint32_t ulChannel)
257 {
258  (void) DRV_IRQ_Disable();
259  s_tIODriver.ptMMIODevice->mmio_pio_out_line_reset_cfg0 = (ulChannel & DRV_DIO_LINE_MSK_MMIO );
260  s_tIODriver.ptMMIODevice->mmio_pio_oe_line_reset_cfg0 = (ulChannel & DRV_DIO_LINE_MSK_MMIO );
261  (void) DRV_IRQ_Enable();
262 }
263 
272 DRV_STATUS_E DRV_DIO_Init(void)
273 {
274  (void) DRV_IRQ_Disable();
275  memset(s_tIODriver.ptGPIODevice, 0, sizeof(*s_tIODriver.ptGPIODevice));
276  s_tIODriver.ptGPIODevice->gpio_app_irq_raw = 0xFFFFFFFF;
277  s_tIODriver.ptMMIODevice->mmio_pio_oe_line_cfg0 = 0x0ul;
278  s_tIODriver.ptMMIODevice->mmio_pio_out_line_cfg0 = 0x0ul;
279  s_tIODriver.ptPIODevice->pio_out = 0x0ul;
280  s_tIODriver.ptPIODevice->pio_oe = 0x0ul;
281  s_tIODriver.ptHIFIODevice->hif_pio_cfg = 0x80000008ul;
282  s_tIODriver.ptHIFIODevice->hif_pio_oe0 = 0x0ul;
283  s_tIODriver.ptHIFIODevice->hif_pio_oe1 = 0x0ul;
284  s_tIODriver.ptHIFIODevice->hif_pio_out0 = 0x0ul;
285  s_tIODriver.ptHIFIODevice->hif_pio_out1 = 0x0ul;
286  s_tIODriver.ptHIFIODevice->hif_pio_irq_arm_mask_reset = 0xFFFFFFFF;
287  (void) DRV_IRQ_Enable();
288  DRV_STATUS_E ret = DRV_OK;
289  return ret;
290 }
291 
301 DRV_STATUS_E DRV_DIO_DeInit(void)
302 {
303  DRV_HANDLE_CHECK(s_tIODriver);
304  (void) DRV_IRQ_Disable();
305  memset(s_tIODriver.ptGPIODevice, 0, sizeof(*s_tIODriver.ptGPIODevice));
306  s_tIODriver.ptGPIODevice->gpio_app_irq_raw = 0xFFFFFFFF;
307  s_tIODriver.ptMMIODevice->mmio_pio_oe_line_cfg0 = 0x0ul;
308  s_tIODriver.ptMMIODevice->mmio_pio_out_line_cfg0 = 0x0ul;
309  s_tIODriver.ptPIODevice->pio_out = 0x0ul;
310  s_tIODriver.ptPIODevice->pio_oe = 0x0ul;
311  s_tIODriver.ptHIFIODevice->hif_pio_cfg = 0x80000008ul;
312  s_tIODriver.ptHIFIODevice->hif_pio_oe0 = 0x0ul;
313  s_tIODriver.ptHIFIODevice->hif_pio_oe1 = 0x0ul;
314  s_tIODriver.ptHIFIODevice->hif_pio_out0 = 0x0ul;
315  s_tIODriver.ptHIFIODevice->hif_pio_out1 = 0x0ul;
316  s_tIODriver.ptHIFIODevice->hif_pio_irq_arm_mask_reset = 0xFFFFFFFF;
317  (void) DRV_IRQ_Enable();
318  DRV_STATUS_E ret = DRV_OK;
319  return ret;
320 }
321 
333 DRV_STATUS_E DRV_DIO_ChannelSetMode(DRV_DIO_ID_T ulChannelID, DRV_DIO_MODE_E eMode)
334 {
335  DRV_HANDLE_CHECK(s_tIODriver);
336  DRV_STATUS_E ret = DRV_ERROR;
337  if(ulChannelID <= DRV_DIO_ID_GPIO_MAX && ulChannelID >= DRV_DIO_ID_GPIO_MIN)
338  {
339  if(eMode <= DRV_DIO_MODE_BLINK || eMode == DRV_DIO_MODE_PWM2)
340  {
341  s_tIODriver.ptGPIODevice->gpio_app_cfg_b[ulChannelID - DRV_DIO_ID_GPIO_MIN].mode = eMode;
342  ret = DRV_OK;
343  }
344  else if(eMode == DRV_DIO_MODE_CAPTURE_CONT_FALLING)
345  {
346  s_tIODriver.ptGPIODevice->gpio_app_cfg_b[ulChannelID - DRV_DIO_ID_GPIO_MIN].mode = DRV_DIO_MODE_CAPTURE_CONT_RISING;
347  s_tIODriver.ptGPIODevice->gpio_app_cfg_b[ulChannelID - DRV_DIO_ID_GPIO_MIN].inv = 0x01ul;
348  ret = DRV_OK;
349  }
350  else
351  {
352  ret = DRV_NSUPP;
353  }
354  }
355  else if(ulChannelID <= DRV_DIO_ID_PIO_MAX && ulChannelID >= DRV_DIO_ID_PIO_MIN)
356  {
357  uint32_t ulMSK = (0x1ul << (ulChannelID - DRV_DIO_ID_PIO_MIN));
358  switch (eMode)
359  {
360  case DRV_DIO_MODE_SET:
361  DRV_DIO_SetPIO(ulMSK);
362  ret = DRV_OK;
363  break;
364  case DRV_DIO_MODE_RESET:
365  DRV_DIO_ResetPIO(ulMSK);
366  ret = DRV_OK;
367  break;
368  case DRV_DIO_MODE_READ:
369  DRV_DIO_ReadModePIO(ulMSK);
370  ret = DRV_OK;
371  break;
372 #ifdef DRV_DIO_PIO_IRQ_SUPPORTED
373  case DRV_DIO_MODE_CAPTURE_CONT_FALLING:
374  (void) DRV_IRQ_Disable();
375  s_tIODriver.ptPIODevice->pio_oe &= ~ulMSK;
376  s_tIODriver.ptPIODevice->pio_edge_event |= ulMSK;
377  s_tIODriver.ptPIODevice->pio_in_inv |= ulMSK;
378  (void) DRV_IRQ_Enable();
379  ret = DRV_OK;
380  break;
381  case DRV_DIO_MODE_CAPTURE_CONT_RISING:
382  (void) DRV_IRQ_Disable();
383  s_tIODriver.ptPIODevice->pio_oe &= ~ulMSK;
384  s_tIODriver.ptPIODevice->pio_edge_event |= ulMSK;
385  s_tIODriver.ptPIODevice->pio_in_inv &= ~ulMSK;
386  (void) DRV_IRQ_Enable();
387  ret = DRV_OK;
388  break;
389  case DRV_DIO_MODE_CAPTURE_CONT_HIGH:
390  (void) DRV_IRQ_Disable();
391  s_tIODriver.ptPIODevice->pio_oe &= ~ulMSK;
392  s_tIODriver.ptPIODevice->pio_edge_event &= ~ulMSK;
393  s_tIODriver.ptPIODevice->pio_in_inv &= ~ulMSK;
394  (void) DRV_IRQ_Enable();
395  ret = DRV_OK;
396  break;
397  case DRV_DIO_MODE_CAPTURE_CONT_LOW:
398  (void) DRV_IRQ_Disable();
399  s_tIODriver.ptPIODevice->pio_oe &= ~ulMSK;
400  s_tIODriver.ptPIODevice->pio_edge_event &= ~ulMSK;
401  s_tIODriver.ptPIODevice->pio_in_inv |= ulMSK;
402  (void) DRV_IRQ_Enable();
403  ret = DRV_OK;
404  break;
405 #endif
406  default:
407  ret = DRV_NSUPP;
408  break;
409  }
410  }
411  else if(ulChannelID <= DRV_DIO_ID_MMIO_MAX && ulChannelID >= DRV_DIO_ID_MMIO_MIN)
412  {
413  switch (eMode)
414  {
415  case DRV_DIO_MODE_SET:
416  DRV_DIO_SetMMIO((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_MMIO_MIN)));
417  ret = DRV_OK;
418  break;
419  case DRV_DIO_MODE_RESET:
420  DRV_DIO_ResetMMIO((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_MMIO_MIN)));
421  ret = DRV_OK;
422  break;
423  case DRV_DIO_MODE_READ:
424  DRV_DIO_ReadModeMMIO((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_MMIO_MIN)));
425  ret = DRV_OK;
426  break;
427  default:
428  ret = DRV_NSUPP;
429  break;
430  }
431  }
432  else if(ulChannelID <= DRV_DIO_ID_HIF_MAX && ulChannelID >= DRV_DIO_ID_HIF_MIN)
433  {
434  switch (eMode)
435  {
436  case DRV_DIO_MODE_SET:
437  DRV_DIO_SetHIF((uint64_t) (0x1ull << (ulChannelID - DRV_DIO_ID_HIF_MIN)));
438  ret = DRV_OK;
439  break;
440  case DRV_DIO_MODE_RESET:
441  DRV_DIO_ResetHIF((uint64_t) (0x1ull << (ulChannelID - DRV_DIO_ID_HIF_MIN)));
442  ret = DRV_OK;
443  break;
444  case DRV_DIO_MODE_READ:
445  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (ulChannelID - DRV_DIO_ID_HIF_MIN)));
446  ret = DRV_OK;
447  break;
448  case DRV_DIO_MODE_CAPTURE_CONT_HIGH:
449  switch (ulChannelID)
450  {
451  case DRV_DIO_ID_HIF_DIRQ:
452  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_DIRQ - DRV_DIO_ID_HIF_MIN)));
453  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_dirq_cfg = DRV_DIO_HIF_IRQ_MODE_HIGH;
454  break;
455  case DRV_DIO_ID_HIF_A17:
456  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_A17 - DRV_DIO_ID_HIF_MIN)));
457  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_a17_cfg = DRV_DIO_HIF_IRQ_MODE_HIGH;
458  break;
459  case DRV_DIO_ID_HIF_A16:
460  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_A16 - DRV_DIO_ID_HIF_MIN)));
461  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_a16_cfg = DRV_DIO_HIF_IRQ_MODE_HIGH;
462  break;
463  case DRV_DIO_ID_HIF_D12:
464  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_D12 - DRV_DIO_ID_HIF_MIN)));
465  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_d12_cfg = DRV_DIO_HIF_IRQ_MODE_HIGH;
466  break;
467  default:
468  ret = DRV_NSUPP;
469  break;
470  }
471  break;
472  case DRV_DIO_MODE_CAPTURE_CONT_RISING:
473  switch (ulChannelID)
474  {
475  case DRV_DIO_ID_HIF_DIRQ:
476  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_DIRQ - DRV_DIO_ID_HIF_MIN)));
477  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_dirq_cfg = DRV_DIO_HIF_IRQ_MODE_RISING;
478  break;
479  case DRV_DIO_ID_HIF_A17:
480  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_A17 - DRV_DIO_ID_HIF_MIN)));
481  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_a17_cfg = DRV_DIO_HIF_IRQ_MODE_RISING;
482  break;
483  case DRV_DIO_ID_HIF_A16:
484  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_A16 - DRV_DIO_ID_HIF_MIN)));
485  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_a16_cfg = DRV_DIO_HIF_IRQ_MODE_RISING;
486  break;
487  case DRV_DIO_ID_HIF_D12:
488  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_D12 - DRV_DIO_ID_HIF_MIN)));
489  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_d12_cfg = DRV_DIO_HIF_IRQ_MODE_RISING;
490  break;
491  default:
492  ret = DRV_NSUPP;
493  break;
494  }
495  break;
496  case DRV_DIO_MODE_CAPTURE_CONT_LOW:
497  switch (ulChannelID)
498  {
499  case DRV_DIO_ID_HIF_DIRQ:
500  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_DIRQ - DRV_DIO_ID_HIF_MIN)));
501  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_dirq_cfg = DRV_DIO_HIF_IRQ_MODE_LOW;
502  break;
503  case DRV_DIO_ID_HIF_A17:
504  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_A17 - DRV_DIO_ID_HIF_MIN)));
505  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_a17_cfg = DRV_DIO_HIF_IRQ_MODE_LOW;
506  break;
507  case DRV_DIO_ID_HIF_A16:
508  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_A16 - DRV_DIO_ID_HIF_MIN)));
509  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_a16_cfg = DRV_DIO_HIF_IRQ_MODE_LOW;
510  break;
511  case DRV_DIO_ID_HIF_D12:
512  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_D12 - DRV_DIO_ID_HIF_MIN)));
513  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_d12_cfg = DRV_DIO_HIF_IRQ_MODE_LOW;
514  break;
515  default:
516  ret = DRV_NSUPP;
517  break;
518  }
519  break;
520  case DRV_DIO_MODE_CAPTURE_CONT_FALLING:
521  switch (ulChannelID)
522  {
523  case DRV_DIO_ID_HIF_DIRQ:
524  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_DIRQ - DRV_DIO_ID_HIF_MIN)));
525  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_dirq_cfg = DRV_DIO_HIF_IRQ_MODE_FALLING;
526  break;
527  case DRV_DIO_ID_HIF_A17:
528  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_A17 - DRV_DIO_ID_HIF_MIN)));
529  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_a17_cfg = DRV_DIO_HIF_IRQ_MODE_FALLING;
530  break;
531  case DRV_DIO_ID_HIF_A16:
532  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_A16 - DRV_DIO_ID_HIF_MIN)));
533  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_a16_cfg = DRV_DIO_HIF_IRQ_MODE_FALLING;
534  break;
535  case DRV_DIO_ID_HIF_D12:
536  DRV_DIO_ReadModeHIF((uint64_t) (0x1ull << (DRV_DIO_ID_HIF_D12 - DRV_DIO_ID_HIF_MIN)));
537  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.irq_hif_d12_cfg = DRV_DIO_HIF_IRQ_MODE_FALLING;
538  break;
539  default:
540  ret = DRV_NSUPP;
541  break;
542  }
543  break;
544  default:
545  ret = DRV_NSUPP;
546  break;
547  }
548  }
549  else
550  {
551  ret = DRV_ERROR_PARAM;
552  }
553  return ret;
554 }
555 
566 DRV_STATUS_E DRV_DIO_ChannelInvert(DRV_DIO_ID_T ulChannelID)
567 {
568  DRV_HANDLE_CHECK(s_tIODriver);
569  DRV_STATUS_E ret = DRV_ERROR;
570  if(ulChannelID <= DRV_DIO_ID_GPIO_MAX && ulChannelID >= DRV_DIO_ID_GPIO_MIN)
571  {
572  (void) DRV_IRQ_Disable();
573  s_tIODriver.ptGPIODevice->gpio_app_cfg_b[ulChannelID - DRV_DIO_ID_GPIO_MIN].inv ^= 0x1ul;
574  (void) DRV_IRQ_Enable();
575  ret = DRV_OK;
576  }
577  else if(ulChannelID <= DRV_DIO_ID_PIO_MAX && ulChannelID >= DRV_DIO_ID_PIO_MIN)
578  {
579 #ifdef DRV_DIO_PIO_INVERT_SUPPORTED
580  (void) DRV_IRQ_Disable();
581  s_tIODriver.ptPIODevice->pio_in_inv ^= 0x1ul;
582  (void) DRV_IRQ_Enable();
583  ret = DRV_OK;
584 #else
585  ret = DRV_NSUPP;
586 #endif
587  }
588  else if(ulChannelID <= DRV_DIO_ID_MMIO_MAX && ulChannelID >= DRV_DIO_ID_MMIO_MIN)
589  {
590  //access key protected
591  // (void) DRV_IRQ_Disable();
592  // ptIODriver.ptMMIODevice->cfg[ulChannelID - DRV_DIO_MMIO_MIN_ID].bf.mmio_out_inv ^= 0x1u;
593  // ptIODriver.ptMMIODevice->cfg[ulChannelID - DRV_DIO_MMIO_MIN_ID].bf.mmio_in_inv ^= 0x1u;
594  // (void) DRV_IRQ_Enable();
595  // ptIODriver.eError = DRV_OK;
596  ret = DRV_NSUPP;
597  }
598  else if(ulChannelID <= DRV_DIO_ID_HIF_MAX && ulChannelID >= DRV_DIO_ID_HIF_MIN)
599  {
600  ret = DRV_NSUPP;
601  }
602  else
603  {
604  ret = DRV_ERROR_PARAM;
605  }
606  return ret;
607 }
608 
618 DRV_STATUS_E DRV_DIO_ChannelOutSet(DRV_DIO_ID_T ulChannelID)
619 {
620  DRV_HANDLE_CHECK(s_tIODriver);
621  DRV_STATUS_E ret = DRV_ERROR;
622  if(ulChannelID <= DRV_DIO_ID_GPIO_MAX && ulChannelID >= DRV_DIO_ID_GPIO_MIN)
623  {
624  s_tIODriver.ptGPIODevice->gpio_app_cfg_b[ulChannelID - DRV_DIO_ID_GPIO_MIN].mode = DRV_DIO_MODE_SET;
625  ret = DRV_OK;
626  }
627  else if(ulChannelID <= DRV_DIO_ID_PIO_MAX && ulChannelID >= DRV_DIO_ID_PIO_MIN)
628  {
629  DRV_DIO_SetPIO((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_PIO_MIN)));
630  ret = DRV_OK;
631  }
632  else if(ulChannelID <= DRV_DIO_ID_MMIO_MAX && ulChannelID >= DRV_DIO_ID_MMIO_MIN)
633  {
634  DRV_DIO_SetMMIO((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_MMIO_MIN)));
635  ret = DRV_OK;
636  }
637  else if(ulChannelID <= DRV_DIO_ID_HIF_MAX && ulChannelID >= DRV_DIO_ID_HIF_MIN)
638  {
639  DRV_DIO_SetHIF((uint64_t) (0x1ull << (ulChannelID - DRV_DIO_ID_HIF_MIN)));
640  ret = DRV_OK;
641  }
642  else
643  {
644  ret = DRV_ERROR_PARAM;
645  }
646  return ret;
647 }
648 
660 DRV_STATUS_E DRV_DIO_ChannelOutReset(DRV_DIO_ID_T ulChannelID)
661 {
662  DRV_HANDLE_CHECK(s_tIODriver);
663  DRV_STATUS_E ret = DRV_ERROR;
664  if(ulChannelID <= DRV_DIO_ID_GPIO_MAX && ulChannelID >= DRV_DIO_ID_GPIO_MIN)
665  {
666  s_tIODriver.ptGPIODevice->gpio_app_cfg_b[ulChannelID - DRV_DIO_ID_GPIO_MIN].mode = DRV_DIO_MODE_RESET;
667  ret = DRV_OK;
668  }
669  else if(ulChannelID <= DRV_DIO_ID_PIO_MAX && ulChannelID >= DRV_DIO_ID_PIO_MIN)
670  {
671  DRV_DIO_ResetPIO((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_PIO_MIN)));
672  ret = DRV_OK;
673  }
674  else if(ulChannelID <= DRV_DIO_ID_MMIO_MAX && ulChannelID >= DRV_DIO_ID_MMIO_MIN)
675  {
676  DRV_DIO_ResetMMIO((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_MMIO_MIN)));
677  ret = DRV_OK;
678  }
679  else if(ulChannelID <= DRV_DIO_ID_HIF_MAX && ulChannelID >= DRV_DIO_ID_HIF_MIN)
680  {
681  DRV_DIO_ResetHIF((uint64_t) (0x1ull << (ulChannelID - DRV_DIO_ID_HIF_MIN)));
682  ret = DRV_OK;
683  }
684  else
685  {
686  ret = DRV_ERROR_PARAM;
687  }
688  return ret;
689 }
690 
701 DRV_STATUS_E DRV_DIO_ChannelOutToggle(DRV_DIO_ID_T ulChannelID)
702 {
703  DRV_HANDLE_CHECK(s_tIODriver);
704  DRV_STATUS_E ret = DRV_ERROR;
705  if(ulChannelID <= DRV_DIO_ID_GPIO_MAX && ulChannelID >= DRV_DIO_ID_GPIO_MIN)
706  {
707  uint32_t in;
708  (void) DRV_IRQ_Disable();
709  in = s_tIODriver.ptGPIODevice->gpio_app_cfg[ulChannelID - DRV_DIO_ID_GPIO_MIN];
710  if((in & gpio_app_gpio_app_cfg_mode_Msk) == (DRV_DIO_MODE_SET << gpio_app_gpio_app_cfg_mode_Pos))
711  {
712  s_tIODriver.ptGPIODevice->gpio_app_cfg_b[ulChannelID - DRV_DIO_ID_GPIO_MIN].mode = DRV_DIO_MODE_RESET;
713  ret = DRV_OK;
714  }
715  else if((in & gpio_app_gpio_app_cfg_mode_Msk) == (DRV_DIO_MODE_RESET << gpio_app_gpio_app_cfg_mode_Pos))
716  {
717  s_tIODriver.ptGPIODevice->gpio_app_cfg_b[ulChannelID - DRV_DIO_ID_GPIO_MIN].mode = DRV_DIO_MODE_SET;
718  ret = DRV_OK;
719  }
720  else
721  {
722  ret = DRV_ERROR;
723  }
724  (void) DRV_IRQ_Enable();
725  }
726  else if(ulChannelID <= DRV_DIO_ID_PIO_MAX && ulChannelID >= DRV_DIO_ID_PIO_MIN)
727  {
728  (void) DRV_IRQ_Disable();
729  s_tIODriver.ptPIODevice->pio_out ^= ((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_PIO_MIN)));
730  s_tIODriver.ptPIODevice->pio_oe |= ((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_PIO_MIN)));
731  (void) DRV_IRQ_Enable();
732  ret = DRV_OK;
733  }
734  else if(ulChannelID <= DRV_DIO_ID_MMIO_MAX && ulChannelID >= DRV_DIO_ID_MMIO_MIN)
735  {
736  (void) DRV_IRQ_Disable();
737  s_tIODriver.ptMMIODevice->mmio_pio_out_line_cfg0_b.line ^= ((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_MMIO_MIN)));
738  s_tIODriver.ptMMIODevice->mmio_pio_oe_line_set_cfg0_b.line = ((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_MMIO_MIN)));
739  (void) DRV_IRQ_Enable();
740  ret = DRV_OK;
741  }
742  else if(ulChannelID <= DRV_DIO_ID_HIF_MAX && ulChannelID >= DRV_DIO_ID_HIF_MIN)
743  {
744  (void) DRV_IRQ_Disable();
745  if((ulChannelID - DRV_DIO_ID_HIF_MIN) < 32u)
746  {
747  s_tIODriver.ptHIFIODevice->hif_pio_out0 ^= ((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_HIF_MIN)));
748  s_tIODriver.ptHIFIODevice->hif_pio_oe0 |= ((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_HIF_MIN)));
749  }
750  else
751  {
752  s_tIODriver.ptHIFIODevice->hif_pio_out1 ^= ((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_HIF_MIN - 32)));
753  s_tIODriver.ptHIFIODevice->hif_pio_oe1 |= ((uint32_t) (0x1ul << (ulChannelID - DRV_DIO_ID_HIF_MIN - 32)));
754  }
755  (void) DRV_IRQ_Enable();
756  ret = DRV_OK;
757  }
758  else
759  {
760  ret = DRV_ERROR_PARAM;
761  }
762  return ret;
763 }
764 
774 DRV_STATUS_E DRV_DIO_ChannelInGet(DRV_DIO_ID_T ulChannelID, DRV_DIO_STATE_E * const peState)
775 {
776  DRV_HANDLE_CHECK(s_tIODriver);
777  DRV_STATUS_E ret = DRV_ERROR;
778  if(ulChannelID <= DRV_DIO_ID_GPIO_MAX && ulChannelID >= DRV_DIO_ID_GPIO_MIN)
779  {
780  *peState =
781  ((s_tIODriver.ptGPIODevice->gpio_app_in & (0x01ul << (ulChannelID - DRV_DIO_ID_GPIO_MIN))) != 0) ? DRV_DIO_STATE_SET : DRV_DIO_STATE_RESET;
782  ret = DRV_OK;
783  }
784  else if(ulChannelID <= DRV_DIO_ID_PIO_MAX && ulChannelID >= DRV_DIO_ID_PIO_MIN)
785  {
786  *peState = ((s_tIODriver.ptPIODevice->pio_in & (0x01ul << (ulChannelID - DRV_DIO_ID_PIO_MIN))) != 0) ? DRV_DIO_STATE_SET : DRV_DIO_STATE_RESET;
787  ret = DRV_OK;
788  }
789  else if(ulChannelID <= DRV_DIO_ID_MMIO_MAX && ulChannelID >= DRV_DIO_ID_MMIO_MIN)
790  {
791  *peState =
792  ((s_tIODriver.ptMMIODevice->mmio_in_line_status0_b.line & (0x01ul << (ulChannelID - DRV_DIO_ID_MMIO_MIN))) != 0) ?
793  DRV_DIO_STATE_SET : DRV_DIO_STATE_RESET;
794  ret = DRV_OK;
795  }
796  else if(ulChannelID <= DRV_DIO_ID_HIF_MAX && ulChannelID >= DRV_DIO_ID_HIF_MIN)
797  {
798  s_tIODriver.ptHIFIODevice->hif_pio_cfg_b.in_ctrl = 0x1ul;
799  if((ulChannelID - DRV_DIO_ID_HIF_MIN) < 32)
800  {
801  *peState =
802  ((s_tIODriver.ptHIFIODevice->hif_pio_in0 & (0x01ul << (ulChannelID - DRV_DIO_ID_HIF_MIN))) != 0) ? DRV_DIO_STATE_SET : DRV_DIO_STATE_RESET;
803  }
804  else
805  {
806  *peState =
807  ((s_tIODriver.ptHIFIODevice->hif_pio_in1 & (0x01ul << (ulChannelID - (DRV_DIO_ID_HIF_MIN + 32)))) != 0) ?
808  DRV_DIO_STATE_SET : DRV_DIO_STATE_RESET;
809  }
810  ret = DRV_OK;
811  }
812  else if(ulChannelID == DRV_DIO_ID_BOD)
813  {
814  *peState = (DRV_ASIC_CTRL_DEVICE->asic_ctrl_irq_raw_b.bod_fail == 0) ? DRV_DIO_STATE_SET : DRV_DIO_STATE_RESET;
815  ret = DRV_OK;
816  }
817  else
818  {
819  ret = DRV_ERROR_PARAM;
820  }
821  return ret;
822 }
823 
837 DRV_STATUS_E DRV_DIO_ChannelBlink(DRV_DIO_ID_T ulChannelID, unsigned int sequence, unsigned int seqBitLength, unsigned int cntr, unsigned int once)
838 {
839  DRV_STATUS_E ret = DRV_ERROR;
840  DRV_HANDLE_CHECK(s_tIODriver);
841  if(seqBitLength > 0x1fu || cntr > 0x3u || once > 0x1ul || ulChannelID > DRV_DIO_ID_GPIO_MAX)
842  {
843  return DRV_ERROR_PARAM;
844  }
845  memset(&(s_tIODriver.ptGPIODevice->gpio_app_cfg_b[ulChannelID - DRV_DIO_ID_GPIO_MIN]), 0, 4);
846  s_tIODriver.ptGPIODevice->gpio_app_cfg_b[ulChannelID - DRV_DIO_ID_GPIO_MIN].blink_len = seqBitLength;
847  s_tIODriver.ptGPIODevice->gpio_app_cfg_b[ulChannelID - DRV_DIO_ID_GPIO_MIN].blink_once = once;
848  s_tIODriver.ptGPIODevice->gpio_app_cfg_b[ulChannelID - DRV_DIO_ID_GPIO_MIN].count_ref = cntr;
849  s_tIODriver.ptGPIODevice->gpio_app_cfg_b[ulChannelID - DRV_DIO_ID_GPIO_MIN].mode = DRV_DIO_MODE_BLINK;
850  s_tIODriver.ptGPIODevice->gpio_app_tc[ulChannelID - DRV_DIO_ID_GPIO_MIN] = sequence;
851  return ret;
852 }
853 
868 DRV_STATUS_E DRV_DIO_ChannelIRQMask(DRV_DIO_ID_T ulChannelID)
869 {
870  (void) DRV_IRQ_Disable();
871  DRV_STATUS_E ret = DRV_OK;
872  if(ulChannelID <= DRV_DIO_ID_GPIO_MAX && ulChannelID >= DRV_DIO_ID_GPIO_MIN)
873  {
874  DRV_GPIO_DEVICE->gpio_app_irq_mask_rst = 0x1ul << (ulChannelID - DRV_DIO_ID_GPIO_MIN);
875  }
876 #ifdef DRV_DIO_PIO_IRQ_SUPPORTED
877  else if(ulChannelID <= DRV_DIO_ID_PIO_MAX && ulChannelID >= DRV_DIO_ID_PIO_MIN)
878  {
879  DRV_PIO_DEVICE->pio_irq0_msk_reset = 0x1ul << (ulChannelID - DRV_DIO_ID_PIO_MIN);
880  }
881 #endif
882  else
883  {
884  switch (ulChannelID)
885  {
886  case DRV_DIO_ID_HIF_D12:
887  DRV_HIF_IO_DEVICE->hif_pio_irq_arm_mask_reset = 0x1u;
888  break;
889  case DRV_DIO_ID_HIF_A16:
890  DRV_HIF_IO_DEVICE->hif_pio_irq_arm_mask_reset = 0x2u;
891  break;
892  case DRV_DIO_ID_HIF_A17:
893  DRV_HIF_IO_DEVICE->hif_pio_irq_arm_mask_reset = 0x4u;
894  break;
895  case DRV_DIO_ID_HIF_DIRQ:
896  DRV_HIF_IO_DEVICE->hif_pio_irq_arm_mask_reset = 0x8u;
897  break;
898  case DRV_DIO_ID_BOD:
899  DRV_ASIC_CTRL_DEVICE->asic_ctrl_irq_mask_reset = asic_ctrl_asic_ctrl_irq_mask_reset_bod_fail_Pos;
900  break;
901  default:
902  ret = DRV_ERROR_PARAM;
903  break;
904  }
905  }
906  (void) DRV_IRQ_Enable();
907  return ret;
908 }
909 
924 DRV_STATUS_E DRV_DIO_ChannelIRQUnmask(DRV_DIO_ID_T ulChannelID)
925 {
926  (void) DRV_IRQ_Disable();
927  DRV_STATUS_E ret = DRV_OK;
928  if(ulChannelID <= DRV_DIO_ID_GPIO_MAX && ulChannelID >= DRV_DIO_ID_GPIO_MIN)
929  {
930  DRV_GPIO_DEVICE->gpio_app_irq_mask_set = 0x1ul << (ulChannelID - DRV_DIO_ID_GPIO_MIN);
931  }
932 #ifdef DRV_DIO_PIO_IRQ_SUPPORTED
933  else if(ulChannelID <= DRV_DIO_ID_PIO_MAX && ulChannelID >= DRV_DIO_ID_PIO_MIN)
934  {
935  DRV_PIO_DEVICE->pio_irq0_msk_set = 0x1ul << (ulChannelID - DRV_DIO_ID_PIO_MIN);
936  }
937 #endif
938  else
939  {
940  switch (ulChannelID)
941  {
942  case DRV_DIO_ID_HIF_D12:
943  DRV_HIF_IO_DEVICE->hif_pio_irq_arm_mask_set = 0x1u;
944  break;
945  case DRV_DIO_ID_HIF_A16:
946  DRV_HIF_IO_DEVICE->hif_pio_irq_arm_mask_set = 0x2u;
947  break;
948  case DRV_DIO_ID_HIF_A17:
949  DRV_HIF_IO_DEVICE->hif_pio_irq_arm_mask_set = 0x4u;
950  break;
951  case DRV_DIO_ID_HIF_DIRQ:
952  DRV_HIF_IO_DEVICE->hif_pio_irq_arm_mask_set = 0x8u;
953  break;
954  case DRV_DIO_ID_BOD:
955  DRV_ASIC_CTRL_DEVICE->asic_ctrl_irq_mask_set = asic_ctrl_asic_ctrl_irq_mask_reset_bod_fail_Pos;
956  break;
957  default:
958  ret = DRV_ERROR_PARAM;
959  break;
960  }
961  }
962  (void) DRV_IRQ_Enable();
963  return ret;
964 }
965 
987 DRV_STATUS_E DRV_DIO_ChannelIRQAttach(DRV_DIO_ID_T ulChannelID, DRV_CALLBACK_F pfnUserClb, void* pvUser)
988 {
989  (void) DRV_IRQ_Disable();
990  DRV_STATUS_E ret = DRV_OK;
991  if(ulChannelID <= DRV_DIO_ID_GPIO_MAX && ulChannelID >= DRV_DIO_ID_GPIO_MIN)
992  {
993  s_afnIRQHandler[ulChannelID - DRV_DIO_ID_GPIO_MIN] = pfnUserClb;
994  s_apIRQHandlerHandles[ulChannelID - DRV_DIO_ID_GPIO_MIN] = pvUser;
995  DRV_NVIC_ClearPendingIRQ((IRQn_Type) (DRV_GPIO0_IRQ + ulChannelID - DRV_DIO_ID_GPIO_MIN));
996  if(pfnUserClb != 0)
997  {
998  DRV_NVIC_EnableIRQ((IRQn_Type) (DRV_GPIO0_IRQ + ulChannelID - DRV_DIO_ID_GPIO_MIN));
999  }
1000  else
1001  {
1002  DRV_NVIC_DisableIRQ((IRQn_Type) (DRV_GPIO0_IRQ + ulChannelID - DRV_DIO_ID_GPIO_MIN));
1003  }
1004  }
1005 #ifdef DRV_DIO_PIO_IRQ_SUPPORTED
1006  else if(ulChannelID <= DRV_DIO_ID_PIO_MAX && ulChannelID >= DRV_DIO_ID_PIO_MIN)
1007  {
1008  s_afnIRQHandler[DRV_GPIO_IRQ_COUNT + DRV_HIF_IRQ_COUNT + DRV_BOD_IRQ_COUNT + ulChannelID - DRV_DIO_ID_PIO_MIN] = pfnUserClb;
1009  s_apIRQHandlerHandles[DRV_GPIO_IRQ_COUNT + DRV_HIF_IRQ_COUNT + DRV_BOD_IRQ_COUNT + ulChannelID - DRV_DIO_ID_PIO_MIN] = pvUser;
1010  DRV_NVIC_ClearPendingIRQ(DRV_PIO_IRQ);
1011  DRV_NVIC_EnableIRQ(DRV_PIO_IRQ);
1012  }
1013 #endif
1014  else
1015  {
1016  switch (ulChannelID)
1017  {
1018  case DRV_DIO_ID_HIF_D12:
1019  s_afnIRQHandler[DRV_GPIO_IRQ_COUNT] = pfnUserClb;
1020  s_apIRQHandlerHandles[DRV_GPIO_IRQ_COUNT] = pvUser;
1021  DRV_NVIC_ClearPendingIRQ(DRV_HIFPIO_IRQ);
1022  DRV_NVIC_EnableIRQ(DRV_HIFPIO_IRQ);
1023  break;
1024  case DRV_DIO_ID_HIF_A16:
1025  s_afnIRQHandler[DRV_GPIO_IRQ_COUNT + 1] = pfnUserClb;
1026  s_apIRQHandlerHandles[DRV_GPIO_IRQ_COUNT + 1] = pvUser;
1027  DRV_NVIC_ClearPendingIRQ(DRV_HIFPIO_IRQ);
1028  DRV_NVIC_EnableIRQ(DRV_HIFPIO_IRQ);
1029  break;
1030  case DRV_DIO_ID_HIF_A17:
1031  s_afnIRQHandler[DRV_GPIO_IRQ_COUNT + 2] = pfnUserClb;
1032  s_apIRQHandlerHandles[DRV_GPIO_IRQ_COUNT + 2] = pvUser;
1033  DRV_NVIC_ClearPendingIRQ(DRV_HIFPIO_IRQ);
1034  DRV_NVIC_EnableIRQ(DRV_HIFPIO_IRQ);
1035  break;
1036  case DRV_DIO_ID_HIF_DIRQ:
1037  s_afnIRQHandler[DRV_GPIO_IRQ_COUNT + 3] = pfnUserClb;
1038  s_apIRQHandlerHandles[DRV_GPIO_IRQ_COUNT + 3] = pvUser;
1039  DRV_NVIC_ClearPendingIRQ(DRV_HIFPIO_IRQ);
1040  DRV_NVIC_EnableIRQ(DRV_HIFPIO_IRQ);
1041  break;
1042  case DRV_DIO_ID_BOD:
1043  s_afnIRQHandler[DRV_GPIO_IRQ_COUNT + DRV_HIF_IRQ_COUNT] = pfnUserClb;
1044  s_apIRQHandlerHandles[DRV_GPIO_IRQ_COUNT + DRV_HIF_IRQ_COUNT] = pvUser;
1045  DRV_NVIC_ClearPendingIRQ(DRV_BOD_IRQ);
1046  if(pfnUserClb != 0)
1047  {
1048  DRV_NVIC_EnableIRQ(DRV_BOD_IRQ);
1049  }
1050  else
1051  {
1052  DRV_NVIC_DisableIRQ(DRV_BOD_IRQ);
1053  }
1054  break;
1055  default:
1056  ret = DRV_ERROR_PARAM;
1057  break;
1058  }
1059  }
1060  (void) DRV_IRQ_Enable();
1061  return ret;
1062 }
1063 
1072 DRV_STATUS_E DRV_DIO_HifIRQFilterEnable(void)
1073 {
1074  DRV_HIF_IO_DEVICE->hif_pio_cfg_b.filter_irqs = 1u;
1075  return DRV_OK;
1076 }
1077 
1086 DRV_STATUS_E DRV_DIO_HifIRQFilterDisable(void)
1087 {
1088  DRV_HIF_IO_DEVICE->hif_pio_cfg_b.filter_irqs = 0u;
1089  return DRV_OK;
1090 }
1091 
1101 DRV_STATUS_E DRV_DIO_LineMaskedSet(DRV_DIO_LINE_E eLine, DRV_DIO_MSK_T ullMask, DRV_DIO_MSK_T ullChannels)
1102 {
1103  DRV_HANDLE_CHECK(s_tIODriver);
1104  DRV_STATUS_E ret = DRV_OK;
1105  uint64_t tmp;
1106  (void) DRV_IRQ_Disable();
1107  if(eLine == DRV_DIO_LINE_HIF)
1108  {
1109  tmp = s_tIODriver.ptHIFIODevice->hif_pio_out0 & ~(ullMask);
1110  s_tIODriver.ptHIFIODevice->hif_pio_out0 = tmp | (ullChannels & DRV_DIO_LINE_MSK_HIF & ullMask);
1111  tmp = s_tIODriver.ptHIFIODevice->hif_pio_out1 & ~(ullMask >> 32u);
1112  s_tIODriver.ptHIFIODevice->hif_pio_out1 = tmp | ((ullChannels & DRV_DIO_LINE_MSK_HIF & ullMask) >> 32u);
1113  }
1114  else if(eLine == DRV_DIO_LINE_GPIO)
1115  {
1116  tmp = s_tIODriver.ptGPIODevice->gpio_app_line & ~ullMask;
1117  s_tIODriver.ptGPIODevice->gpio_app_line = tmp | (ullChannels & DRV_DIO_LINE_MSK_GPIO & ullMask);
1118  }
1119  else if(eLine == DRV_DIO_LINE_PIO)
1120  {
1121  tmp = s_tIODriver.ptPIODevice->pio_out & ~ullMask;
1122  s_tIODriver.ptPIODevice->pio_out = tmp | (ullChannels & DRV_DIO_LINE_MSK_PIO & ullMask);
1123  }
1124  else if(eLine == DRV_DIO_LINE_MMIO)
1125  {
1126  tmp = s_tIODriver.ptMMIODevice->mmio_pio_out_line_cfg0 & ~ullMask;
1127  s_tIODriver.ptMMIODevice->mmio_pio_out_line_cfg0 = tmp | (ullChannels & DRV_DIO_LINE_MSK_MMIO & ullMask);
1128  }
1129  else
1130  {
1131  ret = DRV_ERROR_PARAM;
1132  }
1133  (void) DRV_IRQ_Enable();
1134  return ret;
1135 }
1136 
1145 DRV_STATUS_E DRV_DIO_LineOutSet(DRV_DIO_LINE_E eLine, DRV_DIO_MSK_T ullChannels)
1146 {
1147  DRV_HANDLE_CHECK(s_tIODriver);
1148  DRV_STATUS_E ret = DRV_OK;
1149  (void) DRV_IRQ_Disable();
1150  if(eLine == DRV_DIO_LINE_HIF)
1151  {
1152  s_tIODriver.ptHIFIODevice->hif_pio_out0 |= (ullChannels & DRV_DIO_LINE_MSK_HIF );
1153  s_tIODriver.ptHIFIODevice->hif_pio_out1 |= ((ullChannels & DRV_DIO_LINE_MSK_HIF ) >> 32u);
1154  }
1155  else if(eLine == DRV_DIO_LINE_GPIO)
1156  {
1157  s_tIODriver.ptGPIODevice->gpio_app_line |= (ullChannels & DRV_DIO_LINE_MSK_GPIO );
1158  }
1159  else if(eLine == DRV_DIO_LINE_PIO)
1160  {
1161  s_tIODriver.ptPIODevice->pio_out |= (ullChannels & DRV_DIO_LINE_MSK_PIO );
1162  }
1163  else if(eLine == DRV_DIO_LINE_MMIO)
1164  {
1165  s_tIODriver.ptMMIODevice->mmio_pio_out_line_set_cfg0 = (ullChannels & DRV_DIO_LINE_MSK_MMIO );
1166  }
1167  else
1168  {
1169  ret = DRV_ERROR_PARAM;
1170  }
1171 
1172  (void) DRV_IRQ_Enable();
1173  return ret;
1174 }
1175 
1184 DRV_STATUS_E DRV_DIO_LineOutReset(DRV_DIO_LINE_E eLine, DRV_DIO_MSK_T ullChannels)
1185 {
1186  DRV_HANDLE_CHECK(s_tIODriver);
1187  DRV_STATUS_E ret = DRV_OK;
1188  (void) DRV_IRQ_Disable();
1189  if(eLine == DRV_DIO_LINE_HIF)
1190  {
1191  s_tIODriver.ptHIFIODevice->hif_pio_out0 &= ~(ullChannels & DRV_DIO_LINE_MSK_HIF );
1192  s_tIODriver.ptHIFIODevice->hif_pio_out1 &= ~((ullChannels & DRV_DIO_LINE_MSK_HIF ) >> 32u);
1193  }
1194  else if(eLine == DRV_DIO_LINE_GPIO)
1195  {
1196  s_tIODriver.ptGPIODevice->gpio_app_line &= ~(ullChannels & DRV_DIO_LINE_MSK_GPIO );
1197  }
1198  else if(eLine == DRV_DIO_LINE_PIO)
1199  {
1200  s_tIODriver.ptPIODevice->pio_out &= ~(ullChannels & DRV_DIO_LINE_MSK_PIO );
1201  }
1202  else if(eLine == DRV_DIO_LINE_MMIO)
1203  {
1204  s_tIODriver.ptMMIODevice->mmio_pio_out_line_reset_cfg0 = (ullChannels & DRV_DIO_LINE_MSK_MMIO );
1205  }
1206  else
1207  {
1208  ret = DRV_ERROR_PARAM;
1209  }
1210  (void) DRV_IRQ_Enable();
1211  return ret;
1212 }
1213 
1223 DRV_STATUS_E DRV_DIO_LineOutEnableSet(DRV_DIO_LINE_E eLine, DRV_DIO_MSK_T ullChannels)
1224 {
1225  DRV_HANDLE_CHECK(s_tIODriver);
1226  DRV_STATUS_E ret = DRV_OK;
1227  (void) DRV_IRQ_Disable();
1228  if(eLine == DRV_DIO_LINE_HIF)
1229  {
1230  s_tIODriver.ptHIFIODevice->hif_pio_oe0 |= (ullChannels & DRV_DIO_LINE_MSK_HIF );
1231  s_tIODriver.ptHIFIODevice->hif_pio_oe1 |= ((ullChannels & DRV_DIO_LINE_MSK_HIF ) >> 32u);
1232  }
1233  else if(eLine == DRV_DIO_LINE_GPIO)
1234  {
1235  int i = 0;
1236  unsigned int ch = (ullChannels & DRV_DIO_LINE_MSK_GPIO );
1237  for(; i < 8; i++)
1238  {
1239  if((ch & 0x01u << i) > 0)
1240  {
1241  s_tIODriver.ptGPIODevice->gpio_app_cfg[i] = DRV_DIO_MODE_LINE;
1242  }
1243  }
1244  }
1245  else if(eLine == DRV_DIO_LINE_PIO)
1246  {
1247  s_tIODriver.ptPIODevice->pio_oe |= (ullChannels & DRV_DIO_LINE_MSK_PIO );
1248  }
1249  else if(eLine == DRV_DIO_LINE_MMIO)
1250  {
1251  s_tIODriver.ptMMIODevice->mmio_pio_oe_line_set_cfg0 = (ullChannels & DRV_DIO_LINE_MSK_MMIO );
1252  }
1253  else
1254  {
1255  ret = DRV_ERROR_PARAM;
1256  }
1257 
1258  (void) DRV_IRQ_Enable();
1259  return ret;
1260 }
1261 
1271 DRV_STATUS_E DRV_DIO_LineOutEnableReset(DRV_DIO_LINE_E eLine, DRV_DIO_MSK_T ullChannels)
1272 {
1273  DRV_HANDLE_CHECK(s_tIODriver);
1274  DRV_STATUS_E ret = DRV_OK;
1275  (void) DRV_IRQ_Disable();
1276  if(eLine == DRV_DIO_LINE_HIF)
1277  {
1278  s_tIODriver.ptHIFIODevice->hif_pio_oe0 &= ~(ullChannels & DRV_DIO_LINE_MSK_HIF );
1279  s_tIODriver.ptHIFIODevice->hif_pio_oe1 &= ~((ullChannels & DRV_DIO_LINE_MSK_HIF ) >> 32u);
1280  }
1281  else if(eLine == DRV_DIO_LINE_GPIO)
1282  {
1283  int i = 0;
1284  unsigned int ch = (ullChannels & DRV_DIO_LINE_MSK_GPIO );
1285  for(; i < 8; i++)
1286  {
1287  if((ch & 0x01u << i) > 0)
1288  {
1289  s_tIODriver.ptGPIODevice->gpio_app_cfg[i] = DRV_DIO_MODE_READ;
1290  }
1291  }
1292  }
1293  else if(eLine == DRV_DIO_LINE_PIO)
1294  {
1295  s_tIODriver.ptPIODevice->pio_oe &= ~(ullChannels & DRV_DIO_LINE_MSK_PIO );
1296  }
1297  else if(eLine == DRV_DIO_LINE_MMIO)
1298  {
1299  s_tIODriver.ptMMIODevice->mmio_pio_oe_line_reset_cfg0 = (ullChannels & DRV_DIO_LINE_MSK_MMIO );
1300  }
1301  else
1302  {
1303  ret = DRV_ERROR_PARAM;
1304  }
1305  (void) DRV_IRQ_Enable();
1306  return ret;
1307 }
1308 
1318 DRV_STATUS_E DRV_DIO_LineInGet(DRV_DIO_LINE_E eLine, DRV_DIO_MSK_T * const pullChannels)
1319 {
1320  DRV_HANDLE_CHECK(s_tIODriver);
1321  DRV_STATUS_E ret = DRV_OK;
1322  (void) DRV_IRQ_Disable();
1323  (*pullChannels) = 0x00ull;
1324  if(eLine == DRV_DIO_LINE_HIF)
1325  {
1326  (*pullChannels) = (uint64_t) s_tIODriver.ptHIFIODevice->hif_pio_in1;
1327  (*pullChannels) <<= 32;
1328  (*pullChannels) |= (uint64_t) s_tIODriver.ptHIFIODevice->hif_pio_in0;
1329  }
1330  else if(eLine == DRV_DIO_LINE_GPIO)
1331  {
1332  *pullChannels = s_tIODriver.ptGPIODevice->gpio_app_in;
1333  }
1334  else if(eLine == DRV_DIO_LINE_PIO)
1335  {
1336  *pullChannels = s_tIODriver.ptPIODevice->pio_in;
1337  }
1338  else if(eLine == DRV_DIO_LINE_MMIO)
1339  {
1340  *pullChannels = s_tIODriver.ptMMIODevice->mmio_in_line_status0;
1341  }
1342  else
1343  {
1344  ret = DRV_ERROR_PARAM;
1345  }
1346  (void) DRV_IRQ_Enable();
1347  return ret;
1348 }
1349 
1357 void GPIO0_IRQHandler(void)
1358 {
1359  DRV_DIO_GPIO0_Callback();
1360  DRV_GPIO_DEVICE->gpio_app_irq_raw = gpio_app_gpio_app_irq_mask_rst_gpio_app0_Msk;
1361 }
1362 
1369 __WEAK void DRV_DIO_GPIO0_Callback(void)
1370 {
1371  static unsigned const int nr = 0;
1372  if(s_afnIRQHandler[nr] != 0)
1373  {
1374  s_afnIRQHandler[nr]((void*) DRV_DIO_ID_GPIO_0, s_apIRQHandlerHandles[nr]);
1375  }
1376 }
1377 
1385 void GPIO1_IRQHandler(void)
1386 {
1387  DRV_DIO_GPIO1_Callback();
1388  DRV_GPIO_DEVICE->gpio_app_irq_raw = gpio_app_gpio_app_irq_mask_rst_gpio_app1_Msk;
1389 }
1390 
1397 __WEAK void DRV_DIO_GPIO1_Callback(void)
1398 {
1399  static unsigned const int nr = 1;
1400  if(s_afnIRQHandler[nr] != 0)
1401  {
1402  s_afnIRQHandler[nr]((void*) DRV_DIO_ID_GPIO_1, s_apIRQHandlerHandles[nr]);
1403  }
1404 }
1405 
1413 void GPIO2_IRQHandler(void)
1414 {
1415  DRV_DIO_GPIO2_Callback();
1416  DRV_GPIO_DEVICE->gpio_app_irq_raw = gpio_app_gpio_app_irq_mask_rst_gpio_app2_Msk;
1417 }
1418 
1425 __WEAK void DRV_DIO_GPIO2_Callback(void)
1426 {
1427  static unsigned const int nr = 2;
1428  if(s_afnIRQHandler[nr] != 0)
1429  {
1430  s_afnIRQHandler[nr]((void*) DRV_DIO_ID_GPIO_2, s_apIRQHandlerHandles[nr]);
1431  }
1432 }
1433 
1441 void GPIO3_IRQHandler(void)
1442 {
1443  DRV_DIO_GPIO3_Callback();
1444  DRV_GPIO_DEVICE->gpio_app_irq_raw = gpio_app_gpio_app_irq_mask_rst_gpio_app3_Msk;
1445 }
1446 
1453 __WEAK void DRV_DIO_GPIO3_Callback(void)
1454 {
1455  static unsigned const int nr = 3;
1456  if(s_afnIRQHandler[nr] != 0)
1457  {
1458  s_afnIRQHandler[nr]((void*) DRV_DIO_ID_GPIO_3, s_apIRQHandlerHandles[nr]);
1459  }
1460 }
1461 
1469 void GPIO4_IRQHandler(void)
1470 {
1471  DRV_DIO_GPIO4_Callback();
1472  DRV_GPIO_DEVICE->gpio_app_irq_raw = gpio_app_gpio_app_irq_mask_rst_gpio_app4_Msk;
1473 }
1474 
1481 __WEAK void DRV_DIO_GPIO4_Callback(void)
1482 {
1483  static unsigned const int nr = 4;
1484  if(s_afnIRQHandler[nr] != 0)
1485  {
1486  s_afnIRQHandler[nr]((void*) DRV_DIO_ID_GPIO_4, s_apIRQHandlerHandles[nr]);
1487  }
1488 }
1489 
1497 void GPIO5_IRQHandler(void)
1498 {
1499  DRV_DIO_GPIO5_Callback();
1500  DRV_GPIO_DEVICE->gpio_app_irq_raw = gpio_app_gpio_app_irq_mask_rst_gpio_app5_Msk;
1501 }
1502 
1509 __WEAK void DRV_DIO_GPIO5_Callback(void)
1510 {
1511  static unsigned const int nr = 5;
1512  if(s_afnIRQHandler[nr] != 0)
1513  {
1514  s_afnIRQHandler[nr]((void*) DRV_DIO_ID_GPIO_5, s_apIRQHandlerHandles[nr]);
1515  }
1516 }
1517 
1525 void GPIO6_IRQHandler(void)
1526 {
1527  DRV_DIO_GPIO6_Callback();
1528  DRV_GPIO_DEVICE->gpio_app_irq_raw = gpio_app_gpio_app_irq_mask_rst_gpio_app6_Msk;
1529 }
1530 
1537 __WEAK void DRV_DIO_GPIO6_Callback(void)
1538 {
1539  static unsigned const int nr = 6;
1540  if(s_afnIRQHandler[nr] != 0)
1541  {
1542  s_afnIRQHandler[nr]((void*) DRV_DIO_ID_GPIO_6, s_apIRQHandlerHandles[nr]);
1543  }
1544 }
1545 
1553 void GPIO7_IRQHandler(void)
1554 {
1555  DRV_DIO_GPIO7_Callback();
1556  DRV_GPIO_DEVICE->gpio_app_irq_raw = gpio_app_gpio_app_irq_mask_rst_gpio_app7_Msk;
1557 }
1558 
1566 __WEAK void DRV_DIO_GPIO7_Callback(void)
1567 {
1568  static unsigned const int nr = 7;
1569  if(s_afnIRQHandler[nr] != 0)
1570  {
1571  s_afnIRQHandler[nr]((void*) DRV_DIO_ID_GPIO_7, s_apIRQHandlerHandles[nr]);
1572  }
1573 }
1574 
1582 void ASIC_IRQHandler(void)
1583 {
1584  DRV_DIO_BOD_Callback();
1585  DRV_ASIC_CTRL_DEVICE->asic_ctrl_irq_raw = asic_ctrl_asic_ctrl_irq_raw_bod_fail_Pos;
1586 }
1587 
1595 __WEAK void DRV_DIO_BOD_Callback(void)
1596 {
1597  static unsigned const int nr = 12;
1598  if(s_afnIRQHandler[nr] != 0)
1599  {
1600  s_afnIRQHandler[nr]((void*) DRV_DIO_ID_BOD, s_apIRQHandlerHandles[nr]);
1601  }
1602 }
1603 
1611 void HIFPIO_IRQHandler(void)
1612 {
1613  DRV_DIO_HIFPIO_Callback();
1614  DRV_HIF_IO_DEVICE->hif_pio_irq_raw = 0xFFFFFFFF;
1615 }
1616 
1625 __WEAK void DRV_DIO_HIFPIO_Callback(void)
1626 {
1627  if(DRV_HIF_IO_DEVICE->hif_pio_irq_arm_masked_b.irq_hif_d12)
1628  {
1629  if(s_afnIRQHandler[DRV_GPIO_IRQ_COUNT] != 0)
1630  {
1631  s_afnIRQHandler[DRV_GPIO_IRQ_COUNT]((void*) DRV_DIO_ID_HIF_D12, s_apIRQHandlerHandles[DRV_GPIO_IRQ_COUNT]);
1632  }
1633  DRV_HIF_IO_DEVICE->hif_pio_irq_raw = hif_io_ctrl_hif_pio_irq_raw_irq_hif_d12_Msk;
1634  }
1635  if(DRV_HIF_IO_DEVICE->hif_pio_irq_arm_masked_b.irq_hif_a16)
1636  {
1637  if(s_afnIRQHandler[DRV_GPIO_IRQ_COUNT + 1] != 0)
1638  {
1639  s_afnIRQHandler[DRV_GPIO_IRQ_COUNT + 1]((void*) DRV_DIO_ID_HIF_A16, s_apIRQHandlerHandles[DRV_GPIO_IRQ_COUNT + 1]);
1640  }
1641  DRV_HIF_IO_DEVICE->hif_pio_irq_raw = hif_io_ctrl_hif_pio_irq_raw_irq_hif_a16_Msk;
1642  }
1643  if(DRV_HIF_IO_DEVICE->hif_pio_irq_arm_masked_b.irq_hif_a17)
1644  {
1645  if(s_afnIRQHandler[DRV_GPIO_IRQ_COUNT + 2] != 0)
1646  {
1647  s_afnIRQHandler[DRV_GPIO_IRQ_COUNT + 2]((void*) DRV_DIO_ID_HIF_A17, s_apIRQHandlerHandles[DRV_GPIO_IRQ_COUNT + 2]);
1648  }
1649  DRV_HIF_IO_DEVICE->hif_pio_irq_raw = hif_io_ctrl_hif_pio_irq_raw_irq_hif_a17_Msk;
1650  }
1651  if(DRV_HIF_IO_DEVICE->hif_pio_irq_arm_masked_b.irq_hif_dirq)
1652  {
1653  if(s_afnIRQHandler[DRV_GPIO_IRQ_COUNT + 3] != 0)
1654  {
1655  s_afnIRQHandler[DRV_GPIO_IRQ_COUNT + 3]((void*) DRV_DIO_ID_HIF_DIRQ, s_apIRQHandlerHandles[DRV_GPIO_IRQ_COUNT + 3]);
1656  }
1657  DRV_HIF_IO_DEVICE->hif_pio_irq_raw = hif_io_ctrl_hif_pio_irq_raw_irq_hif_dirq_Msk;
1658  }
1659 }
1660 
1661 #ifdef DRV_DIO_PIO_IRQ_SUPPORTED
1662 
1670 void PIO0_IRQHandler(void)
1671 {
1672  DRV_DIO_PIO_Callback();
1673 }
1674 
1683 __WEAK void DRV_DIO_PIO_Callback(void)
1684 {
1685  uint32_t ulIRQ = DRV_PIO_DEVICE->pio_irq_raw & DRV_PIO_DEVICE->pio_irq0_masked;
1686  uint32_t ulChannelID = 0;
1687  uint32_t ulMSK = 0x01u;
1688  while(ulIRQ != 0)
1689  {
1690  if(ulIRQ & ulMSK)
1691  {
1692  s_afnIRQHandler[DRV_GPIO_IRQ_COUNT + DRV_HIF_IRQ_COUNT + DRV_BOD_IRQ_COUNT + ulChannelID]((void*) ((uintptr_t) DRV_DIO_ID_PIO_0 + ulChannelID), s_apIRQHandlerHandles[DRV_GPIO_IRQ_COUNT
1693  + DRV_HIF_IRQ_COUNT + DRV_BOD_IRQ_COUNT + ulChannelID]
1694  );
1695  DRV_PIO_DEVICE->pio_irq_raw = ulMSK;
1696  ulIRQ &= ~ulMSK;
1697  }
1698  ulMSK = ulMSK << 1;
1699  if(DRV_PIO_IRQ_COUNT == ulChannelID++)
1700  {
1701  break;
1702  }
1703  }
1704 }
1705 
1706 #endif /* DRV_DIO_PIO_IRQ_SUPPORTED */
1707 /* End of group DIO */
1709 
1710 /*lint -restore */
1711 /*lint -restore */
1712 
1713 #endif /* DRV_DIO_MODULE_DISABLED */
DRV_DIO_ID_GPIO_5
#define DRV_DIO_ID_GPIO_5
Definition: netx_drv_csp_netx90_app.h:237
DRV_DIO_HANDLE_T::DRV_DIO_SetPIO
static __INLINE void DRV_DIO_SetPIO(uint32_t ulChannel)
Helper function.
Definition: netx_drv_dio.c:113
hif_io_ctrl_Type::hif_pio_cfg_b
struct hif_io_ctrl_Type::@3962::@3991 hif_pio_cfg_b
DRV_DIO_ID_GPIO_0
#define DRV_DIO_ID_GPIO_0
Definition: netx_drv_csp_netx90_app.h:232
mmio_ctrl_Type::mmio_pio_oe_line_cfg0
__IOM uint32_t mmio_pio_oe_line_cfg0
Definition: netx90_app.h:14425
DRV_DIO_HANDLE_T
The handle of the driver.
Definition: netx_drv_dio.h:45
s_apIRQHandlerHandles
void * s_apIRQHandlerHandles[DRV_DIO_IRQ_COUNT]
Definition: netx_drv_dio.c:81
gpio_app_Type::gpio_app_in
__IM uint32_t gpio_app_in
Definition: netx90_app.h:24713
DRV_DIO_MODE_SET
Definition: netx_drv_dio.h:87
mmio_ctrl_Type::mmio_pio_oe_line_set_cfg0
__IOM uint32_t mmio_pio_oe_line_set_cfg0
Definition: netx90_app.h:14448
__INLINE
#define __INLINE
Definition: cmsis_armcc.h:56
DRV_DIO_HANDLE_T::DRV_DIO_ChannelIRQUnmask
DRV_STATUS_E DRV_DIO_ChannelIRQUnmask(DRV_DIO_ID_T ulChannelID)
This function unmasks a io channels interrupt.
Definition: netx_drv_dio.c:924
DRV_GPIO_IRQ_COUNT
#define DRV_GPIO_IRQ_COUNT
Definition: netx_drv_csp_netx90_app.h:110
GPIO0_IRQHandler
void GPIO0_IRQHandler(void)
Definition: netx_drv_dio.c:1357
DRV_DIO_LINE_HIF
Definition: netx_drv_dio.h:62
gpio_app_Type::gpio_app_irq_raw
__IOM uint32_t gpio_app_irq_raw
Definition: netx90_app.h:24724
DRV_DIO_LINE_PIO
Definition: netx_drv_dio.h:60
__WEAK
#define __WEAK
Definition: cmsis_armcc.h:71
IRQn_Type
IRQn_Type
Definition: netx90_app.h:57
mmio_ctrl_Type::mmio_pio_out_line_reset_cfg0
__IOM uint32_t mmio_pio_out_line_reset_cfg0
Definition: netx90_app.h:14400
DRV_DIO_MODE_E
DRV_DIO_MODE_E
The mode of the DIO.
Definition: netx_drv_dio.h:78
DRV_DIO_HANDLE_T::ptHIFIODevice
DRV_HIF_IO_DEVICE_T * ptHIFIODevice
Definition: netx_drv_dio.h:50
DRV_DIO_LINE_MSK_HIF
#define DRV_DIO_LINE_MSK_HIF
Definition: netx_drv_csp_netx90_app.h:130
DRV_NVIC_DisableIRQ
void DRV_NVIC_DisableIRQ(IRQn_Type IRQn)
This method disables a given interrupt.
Definition: netx_drv_cortex.c:73
DRV_DIO_ID_HIF_A17
#define DRV_DIO_ID_HIF_A17
Definition: netx_drv_csp_netx90_app.h:320
DRV_HIF_IRQ_COUNT
#define DRV_HIF_IRQ_COUNT
Definition: netx_drv_csp_netx90_app.h:113
DRV_DIO_HANDLE_T::ptGPIODevice
DRV_GPIO_DEVICE_T * ptGPIODevice
Definition: netx_drv_dio.h:47
DRV_DIO_HANDLE_T::DRV_DIO_LineInGet
DRV_STATUS_E DRV_DIO_LineInGet(DRV_DIO_LINE_E eLine, DRV_DIO_MSK_T *const pullChannels)
This function stores the state readable of all channels of all given lines into the channel value...
Definition: netx_drv_dio.c:1318
gpio_app_Type::gpio_app_cfg_b
struct gpio_app_Type::@5163::@5193 gpio_app_cfg_b[8]
hif_io_ctrl_Type::hif_pio_cfg
__IOM uint32_t hif_pio_cfg
Definition: netx90_app.h:14838
DRV_BOD_IRQ
#define DRV_BOD_IRQ
Definition: netx_drv_csp_netx90_app.h:117
GPIO7_IRQHandler
void GPIO7_IRQHandler(void)
Definition: netx_drv_dio.c:1553
pio_app_Type::pio_in
__IM uint32_t pio_in
Definition: netx90_app.h:24911
DRV_DIO_LINE_MSK_MMIO
#define DRV_DIO_LINE_MSK_MMIO
Definition: netx_drv_csp_netx90_app.h:129
DRV_DIO_HANDLE_T::DRV_DIO_ReadModeHIF
static __INLINE void DRV_DIO_ReadModeHIF(uint64_t ulChannel)
Helper function.
Definition: netx_drv_dio.c:203
mmio_ctrl_Type::mmio_pio_oe_line_reset_cfg0
__IOM uint32_t mmio_pio_oe_line_reset_cfg0
Definition: netx90_app.h:14473
hif_io_ctrl_Type::hif_pio_irq_arm_mask_reset
__IOM uint32_t hif_pio_irq_arm_mask_reset
Definition: netx90_app.h:15142
DRV_DIO_ID_HIF_DIRQ
#define DRV_DIO_ID_HIF_DIRQ
Definition: netx_drv_csp_netx90_app.h:327
DRV_DIO_LINE_E
DRV_DIO_LINE_E
Definition: netx_drv_dio.h:56
DRV_DIO_HANDLE_T::DRV_DIO_ResetPIO
static __INLINE void DRV_DIO_ResetPIO(uint32_t ulChannel)
Helper function.
Definition: netx_drv_dio.c:130
DRV_DIO_LINE_MSK_PIO
#define DRV_DIO_LINE_MSK_PIO
Definition: netx_drv_csp_netx90_app.h:128
DRV_DIO_HANDLE_T::DRV_DIO_ChannelOutReset
DRV_STATUS_E DRV_DIO_ChannelOutReset(DRV_DIO_ID_T ulChannelID)
This function sets the mode of the specified channel to reset (low or inverted low).
Definition: netx_drv_dio.c:660
gpio_app_Type::gpio_app_line
__IOM uint32_t gpio_app_line
Definition: netx90_app.h:24703
DRV_NVIC_EnableIRQ
void DRV_NVIC_EnableIRQ(IRQn_Type IRQn)
This method enables a given interrupt.
Definition: netx_drv_cortex.c:64
DRV_DIO_STATE_E
DRV_DIO_STATE_E
The state of the io port.
Definition: netx_drv_dio.h:101
DRV_DIO_HANDLE_T::DRV_DIO_LineOutEnableReset
DRV_STATUS_E DRV_DIO_LineOutEnableReset(DRV_DIO_LINE_E eLine, DRV_DIO_MSK_T ullChannels)
This function Disables output capability on the channels defined.
Definition: netx_drv_dio.c:1271
hif_io_ctrl_Type::hif_pio_in1
__IM uint32_t hif_pio_in1
Definition: netx90_app.h:15059
pio_app_Type::pio_edge_event
__IOM uint32_t pio_edge_event
Definition: netx90_app.h:24973
DRV_HANDLE_CHECK
#define DRV_HANDLE_CHECK(handle)
Definition: netx_drv_dio.c:87
DRV_DIO_HANDLE_T::DRV_DIO_LineOutSet
DRV_STATUS_E DRV_DIO_LineOutSet(DRV_DIO_LINE_E eLine, DRV_DIO_MSK_T ullChannels)
This function sets the channels defined.
Definition: netx_drv_dio.c:1145
DRV_DIO_ID_GPIO_1
#define DRV_DIO_ID_GPIO_1
Definition: netx_drv_csp_netx90_app.h:233
DRV_DIO_ID_GPIO_6
#define DRV_DIO_ID_GPIO_6
Definition: netx_drv_csp_netx90_app.h:238
DRV_DIO_ID_GPIO_2
#define DRV_DIO_ID_GPIO_2
Definition: netx_drv_csp_netx90_app.h:234
DRV_DIO_HANDLE_T::DRV_DIO_SetHIF
static __INLINE void DRV_DIO_SetHIF(uint64_t ulChannel)
Helper function.
Definition: netx_drv_dio.c:164
DRV_ERROR
Definition: netx_drv_def.h:56
DRV_DIO_HANDLE_T::DRV_DIO_ChannelOutToggle
DRV_STATUS_E DRV_DIO_ChannelOutToggle(DRV_DIO_ID_T ulChannelID)
This function toggles the mode of the specified channel if it was set or reset before (from high to l...
Definition: netx_drv_dio.c:701
DRV_DIO_LINE_MSK_GPIO
#define DRV_DIO_LINE_MSK_GPIO
Definition: netx_drv_csp_netx90_app.h:127
DRV_DIO_HIF_IRQ_MODE_LOW
Definition: netx_drv_dio.c:98
DRV_DIO_HIF_IRQ_MODE_HIGH
Definition: netx_drv_dio.c:99
DRV_DIO_HANDLE_T::DRV_DIO_LineOutReset
DRV_STATUS_E DRV_DIO_LineOutReset(DRV_DIO_LINE_E eLine, DRV_DIO_MSK_T ullChannels)
This function resets the channels defined.
Definition: netx_drv_dio.c:1184
gpio_app_gpio_app_irq_mask_rst_gpio_app4_Msk
#define gpio_app_gpio_app_irq_mask_rst_gpio_app4_Msk
Definition: netx90_app.h:47335
DRV_DIO_GPIO3_Callback
void DRV_DIO_GPIO3_Callback(void)
This is the callback of the GPIO 3 IRQ.
Definition: netx_drv_dio.c:1453
DRV_DIO_HANDLE_T::DRV_DIO_ReadModeMMIO
static __INLINE void DRV_DIO_ReadModeMMIO(uint32_t ulChannel)
Helper function.
Definition: netx_drv_dio.c:256
DRV_IRQ_Enable
__STATIC_INLINE int DRV_IRQ_Enable(void)
This is a semaphore function for nested enabling the interrupts.
Definition: netx_drv_cortex.h:133
DRV_DIO_HIF_IRQ_MODE_FALLING
Definition: netx_drv_dio.c:100
DRV_DIO_HANDLE_T::DRV_DIO_LineMaskedSet
DRV_STATUS_E DRV_DIO_LineMaskedSet(DRV_DIO_LINE_E eLine, DRV_DIO_MSK_T ullMask, DRV_DIO_MSK_T ullChannels)
This function sets the channels defined by the mask.
Definition: netx_drv_dio.c:1101
gpio_app_gpio_app_irq_mask_rst_gpio_app1_Msk
#define gpio_app_gpio_app_irq_mask_rst_gpio_app1_Msk
Definition: netx90_app.h:47341
DRV_DIO_HANDLE_T::DRV_DIO_ChannelSetMode
DRV_STATUS_E DRV_DIO_ChannelSetMode(DRV_DIO_ID_T ulChannelID, DRV_DIO_MODE_E eMode)
This function (re)initializes a specific channel and sets its mode.
Definition: netx_drv_dio.c:333
DRV_DIO_HANDLE_T::DRV_DIO_ChannelBlink
DRV_STATUS_E DRV_DIO_ChannelBlink(DRV_DIO_ID_T ulChannelID, unsigned int sequence, unsigned int seqBitLength, unsigned int cntr, unsigned int once)
Definition: netx_drv_dio.c:837
hif_io_ctrl_Type::hif_pio_in0
__IM uint32_t hif_pio_in0
Definition: netx90_app.h:15030
GPIO6_IRQHandler
void GPIO6_IRQHandler(void)
Definition: netx_drv_dio.c:1525
DRV_DIO_ID_BOD
#define DRV_DIO_ID_BOD
Definition: netx_drv_csp_netx90_app.h:331
DRV_DIO_ID_MMIO_MIN
#define DRV_DIO_ID_MMIO_MIN
Definition: netx_drv_csp_netx90_app.h:274
DRV_PIO_IRQ_COUNT
#define DRV_PIO_IRQ_COUNT
Definition: netx_drv_csp_netx90_app.h:115
DRV_DIO_MODE_CAPTURE_CONT_LOW
Definition: netx_drv_dio.h:95
DRV_DIO_HANDLE_T::DRV_DIO_ResetMMIO
static __INLINE void DRV_DIO_ResetMMIO(uint32_t ulChannel)
Helper function.
Definition: netx_drv_dio.c:239
DRV_HIFPIO_IRQ
#define DRV_HIFPIO_IRQ
Definition: netx_drv_csp_netx90_app.h:114
gpio_app_gpio_app_irq_mask_rst_gpio_app0_Msk
#define gpio_app_gpio_app_irq_mask_rst_gpio_app0_Msk
Definition: netx90_app.h:47343
hif_io_ctrl_hif_pio_irq_raw_irq_hif_d12_Msk
#define hif_io_ctrl_hif_pio_irq_raw_irq_hif_d12_Msk
Definition: netx90_app.h:41882
DRV_DIO_ID_GPIO_MIN
#define DRV_DIO_ID_GPIO_MIN
Definition: netx_drv_csp_netx90_app.h:231
DRV_DIO_HANDLE_T::DRV_DIO_HifIRQFilterDisable
DRV_STATUS_E DRV_DIO_HifIRQFilterDisable(void)
This function deactivates the filter on the HIF channels regarding the interrupt sampling.
Definition: netx_drv_dio.c:1086
DRV_DIO_MODE_PWM2
Definition: netx_drv_dio.h:92
DRV_DIO_MODE_READ
Definition: netx_drv_dio.h:81
DRV_DIO_ID_PIO_0
#define DRV_DIO_ID_PIO_0
Definition: netx_drv_csp_netx90_app.h:243
DRV_DIO_PIO_Callback
void DRV_DIO_PIO_Callback(void)
This is the callback of the PIO0 IRQ.
Definition: netx_drv_dio.c:1683
s_tIODriver
DRV_DIO_HANDLE_T const s_tIODriver
Definition: netx_drv_dio.c:71
hif_io_ctrl_Type::hif_pio_out1
__IOM uint32_t hif_pio_out1
Definition: netx90_app.h:14916
gpio_app_gpio_app_irq_mask_rst_gpio_app5_Msk
#define gpio_app_gpio_app_irq_mask_rst_gpio_app5_Msk
Definition: netx90_app.h:47333
DRV_DIO_MSK_T
uint64_t DRV_DIO_MSK_T
Type definition for the driver io channel mask.
Definition: netx_drv_dio.h:69
DRV_DIO_HIFPIO_Callback
void DRV_DIO_HIFPIO_Callback(void)
This is the callback of the HIFPIO IRQ.
Definition: netx_drv_dio.c:1625
netx_drv.h
This file contains all the functions prototypes for the peripheral module driver. ...
mmio_ctrl_Type::mmio_in_line_status0
__IM uint32_t mmio_in_line_status0
Definition: netx90_app.h:14498
GPIO2_IRQHandler
void GPIO2_IRQHandler(void)
Definition: netx_drv_dio.c:1413
DRV_DIO_LINE_GPIO
Definition: netx_drv_dio.h:59
DRV_ERROR_PARAM
Definition: netx_drv_def.h:61
DRV_DIO_MODE_RESET
Definition: netx_drv_dio.h:86
DRV_DIO_MODE_BLINK
Definition: netx_drv_dio.h:90
DRV_DIO_HANDLE_T::DRV_DIO_ChannelInvert
DRV_STATUS_E DRV_DIO_ChannelInvert(DRV_DIO_ID_T ulChannelID)
This function inverts the input/output of a specific channel.
Definition: netx_drv_dio.c:566
HIFPIO_IRQHandler
void HIFPIO_IRQHandler(void)
Definition: netx_drv_dio.c:1611
DRV_DIO_HANDLE_T::DRV_DIO_HifIRQFilterEnable
DRV_STATUS_E DRV_DIO_HifIRQFilterEnable(void)
This function activates the filter on the HIF channels regarding the interrupt sampling.
Definition: netx_drv_dio.c:1072
hif_io_ctrl_Type::hif_pio_oe0
__IOM uint32_t hif_pio_oe0
Definition: netx90_app.h:14957
DRV_DIO_ID_GPIO_4
#define DRV_DIO_ID_GPIO_4
Definition: netx_drv_csp_netx90_app.h:236
DRV_DIO_HANDLE_T::ptMMIODevice
DRV_MMIO_DEVICE_T * ptMMIODevice
Definition: netx_drv_dio.h:49
DRV_DIO_ID_GPIO_7
#define DRV_DIO_ID_GPIO_7
Definition: netx_drv_csp_netx90_app.h:239
DRV_DIO_HANDLE_T::DRV_DIO_ChannelIRQMask
DRV_STATUS_E DRV_DIO_ChannelIRQMask(DRV_DIO_ID_T ulChannelID)
This function masks a io channels interrupt out.
Definition: netx_drv_dio.c:868
DRV_DIO_BOD_Callback
void DRV_DIO_BOD_Callback(void)
This is the callback of the BOD IRQ.
Definition: netx_drv_dio.c:1595
gpio_app_Type::gpio_app_tc
__IOM uint32_t gpio_app_tc[8]
Definition: netx90_app.h:24636
hif_io_ctrl_Type::hif_pio_out0
__IOM uint32_t hif_pio_out0
Definition: netx90_app.h:14884
DRV_DIO_ID_GPIO_MAX
#define DRV_DIO_ID_GPIO_MAX
Definition: netx_drv_csp_netx90_app.h:240
DRV_GPIO_DEVICE
#define DRV_GPIO_DEVICE
Definition: netx_drv_csp_netx90_app.h:105
DRV_ASIC_CTRL_DEVICE
#define DRV_ASIC_CTRL_DEVICE
Definition: netx_drv_csp_netx90_app.h:53
DRV_DIO_HANDLE_T::DRV_DIO_ResetHIF
static __INLINE void DRV_DIO_ResetHIF(uint64_t ulChannel)
Helper function.
Definition: netx_drv_dio.c:184
DRV_DIO_HANDLE_T::DRV_DIO_ChannelInGet
DRV_STATUS_E DRV_DIO_ChannelInGet(DRV_DIO_ID_T ulChannelID, DRV_DIO_STATE_E *const peState)
This function stores the channel state at the given position.
Definition: netx_drv_dio.c:774
DRV_DIO_HANDLE_T::DRV_DIO_LineOutEnableSet
DRV_STATUS_E DRV_DIO_LineOutEnableSet(DRV_DIO_LINE_E eLine, DRV_DIO_MSK_T ullChannels)
This function enables line output capability on the channels defined.
Definition: netx_drv_dio.c:1223
gpio_app_gpio_app_irq_mask_rst_gpio_app3_Msk
#define gpio_app_gpio_app_irq_mask_rst_gpio_app3_Msk
Definition: netx90_app.h:47337
pio_app_Type::pio_out
__IOM uint32_t pio_out
Definition: netx90_app.h:24922
DRV_DIO_GPIO1_Callback
void DRV_DIO_GPIO1_Callback(void)
This is the callback of the GPIO 1 IRQ.
Definition: netx_drv_dio.c:1397
DRV_DIO_GPIO0_Callback
void DRV_DIO_GPIO0_Callback(void)
This is the callback of the GPIO 0 IRQ.
Definition: netx_drv_dio.c:1369
DRV_DIO_HANDLE_T::DRV_DIO_ChannelOutSet
DRV_STATUS_E DRV_DIO_ChannelOutSet(DRV_DIO_ID_T ulChannelID)
This function sets the mode of the specified channel to set (high or inverted high).
Definition: netx_drv_dio.c:618
DRV_DIO_ID_T
uint32_t DRV_DIO_ID_T
Type definition for the driver io channel ids.
Definition: netx_drv_dio.h:73
DRV_CALLBACK_F
void(* DRV_CALLBACK_F)(void *pvDriverHandle, void *pvUserHandle)
The definition of callbacks used in the driver.
Definition: netx_drv_def.h:48
DRV_DIO_ID_HIF_D12
#define DRV_DIO_ID_HIF_D12
Definition: netx_drv_csp_netx90_app.h:298
DRV_STATUS_E
DRV_STATUS_E
DRV Status structures definition.
Definition: netx_drv_def.h:53
pio_app_Type::pio_in_inv
__IOM uint32_t pio_in_inv
Definition: netx90_app.h:24964
DRV_DIO_HIF_IRQ_MODE_RISING
Definition: netx_drv_dio.c:101
DRV_DIO_GPIO6_Callback
void DRV_DIO_GPIO6_Callback(void)
This is the callback of the GPIO 6 IRQ.
Definition: netx_drv_dio.c:1537
DRV_MMIO_DEVICE
#define DRV_MMIO_DEVICE
Definition: netx_drv_csp_netx90_app.h:103
mmio_ctrl_Type::mmio_pio_out_line_cfg0_b
struct mmio_ctrl_Type::@3861::@3895 mmio_pio_out_line_cfg0_b
mmio_ctrl_Type::mmio_pio_out_line_set_cfg0
__IOM uint32_t mmio_pio_out_line_set_cfg0
Definition: netx90_app.h:14376
DRV_DIO_ID_GPIO_3
#define DRV_DIO_ID_GPIO_3
Definition: netx_drv_csp_netx90_app.h:235
DRV_DIO_MODE_CAPTURE_CONT_HIGH
Definition: netx_drv_dio.h:94
DRV_DIO_HANDLE_T::DRV_DIO_DeInit
DRV_STATUS_E DRV_DIO_DeInit(void)
This function disables the global DRV_DIO_APP_HANDLE_T object.
Definition: netx_drv_dio.c:301
DRV_DIO_GPIO2_Callback
void DRV_DIO_GPIO2_Callback(void)
This is the callback of the GPIO 2 IRQ.
Definition: netx_drv_dio.c:1425
mmio_ctrl_Type::mmio_in_line_status0_b
struct mmio_ctrl_Type::@3873::@3901 mmio_in_line_status0_b
gpio_app_gpio_app_irq_mask_rst_gpio_app7_Msk
#define gpio_app_gpio_app_irq_mask_rst_gpio_app7_Msk
Definition: netx90_app.h:47329
DRV_DIO_HANDLE_T::DRV_DIO_ReadModePIO
static __INLINE void DRV_DIO_ReadModePIO(uint32_t ulChannel)
Helper function.
Definition: netx_drv_dio.c:147
GPIO4_IRQHandler
void GPIO4_IRQHandler(void)
Definition: netx_drv_dio.c:1469
DRV_NVIC_ClearPendingIRQ
void DRV_NVIC_ClearPendingIRQ(IRQn_Type IRQn)
This method clears the pending state of a given interrupt.
Definition: netx_drv_cortex.c:143
asic_ctrl_asic_ctrl_irq_mask_reset_bod_fail_Pos
#define asic_ctrl_asic_ctrl_irq_mask_reset_bod_fail_Pos
Definition: netx90_app.h:41080
DRV_HIF_IO_DEVICE
#define DRV_HIF_IO_DEVICE
Definition: netx_drv_csp_netx90_app.h:104
DRV_DIO_STATE_SET
Definition: netx_drv_dio.h:103
pio_app_Type::pio_oe
__IOM uint32_t pio_oe
Definition: netx90_app.h:24933
DRV_DIO_GPIO7_Callback
void DRV_DIO_GPIO7_Callback(void)
This is the callback of the GPIO 7 IRQ.
Definition: netx_drv_dio.c:1566
hif_io_ctrl_Type::hif_pio_oe1
__IOM uint32_t hif_pio_oe1
Definition: netx90_app.h:14989
DRV_DIO_HIF_IRQ_MODE_E
DRV_DIO_HIF_IRQ_MODE_E
Definition: netx_drv_dio.c:96
gpio_app_gpio_app_irq_mask_rst_gpio_app6_Msk
#define gpio_app_gpio_app_irq_mask_rst_gpio_app6_Msk
Definition: netx90_app.h:47331
DRV_PIO_IRQ
#define DRV_PIO_IRQ
Definition: netx_drv_csp_netx90_app.h:116
ASIC_IRQHandler
void ASIC_IRQHandler(void)
Definition: netx_drv_dio.c:1582
DRV_BOD_IRQ_COUNT
#define DRV_BOD_IRQ_COUNT
Definition: netx_drv_csp_netx90_app.h:118
GPIO1_IRQHandler
void GPIO1_IRQHandler(void)
Definition: netx_drv_dio.c:1385
DRV_DIO_HANDLE_T::DRV_DIO_ChannelIRQAttach
DRV_STATUS_E DRV_DIO_ChannelIRQAttach(DRV_DIO_ID_T ulChannelID, DRV_CALLBACK_F pfnUserClb, void *pvUser)
This function attaches a given function to a DIO channels interrupt.
Definition: netx_drv_dio.c:987
DRV_DIO_ID_HIF_A16
#define DRV_DIO_ID_HIF_A16
Definition: netx_drv_csp_netx90_app.h:319
DRV_GPIO0_IRQ
#define DRV_GPIO0_IRQ
Definition: netx_drv_csp_netx90_app.h:112
DRV_DIO_ID_HIF_MIN
#define DRV_DIO_ID_HIF_MIN
Definition: netx_drv_csp_netx90_app.h:285
DRV_DIO_HANDLE_T::ptPIODevice
DRV_PIO_DEVICE_T * ptPIODevice
Definition: netx_drv_dio.h:48
hif_io_ctrl_hif_pio_irq_raw_irq_hif_a17_Msk
#define hif_io_ctrl_hif_pio_irq_raw_irq_hif_a17_Msk
Definition: netx90_app.h:41878
GPIO3_IRQHandler
void GPIO3_IRQHandler(void)
Definition: netx_drv_dio.c:1441
DRV_DIO_HANDLE_T::DRV_DIO_SetMMIO
static __INLINE void DRV_DIO_SetMMIO(uint32_t ulChannel)
Helper function.
Definition: netx_drv_dio.c:222
mmio_ctrl_Type::mmio_pio_out_line_cfg0
__IOM uint32_t mmio_pio_out_line_cfg0
Definition: netx90_app.h:14353
s_afnIRQHandler
DRV_CALLBACK_F s_afnIRQHandler[DRV_DIO_IRQ_COUNT]
Definition: netx_drv_dio.c:76
DRV_DIO_GPIO4_Callback
void DRV_DIO_GPIO4_Callback(void)
This is the callback of the GPIO 4 IRQ.
Definition: netx_drv_dio.c:1481
DRV_OK
Definition: netx_drv_def.h:55
DRV_DIO_HANDLE_T::DRV_DIO_Init
DRV_STATUS_E DRV_DIO_Init(void)
This function initializes the global DRV_DIO_APP_HANDLE_T object.
Definition: netx_drv_dio.c:272
gpio_app_gpio_app_cfg_mode_Pos
#define gpio_app_gpio_app_cfg_mode_Pos
Definition: netx90_app.h:47230
GPIO5_IRQHandler
void GPIO5_IRQHandler(void)
Definition: netx_drv_dio.c:1497
DRV_DIO_MODE_LINE
Definition: netx_drv_dio.h:88
DRV_DIO_STATE_RESET
Definition: netx_drv_dio.h:104
DRV_DIO_ID_PIO_MIN
#define DRV_DIO_ID_PIO_MIN
Definition: netx_drv_csp_netx90_app.h:242
DRV_IRQ_Disable
__STATIC_INLINE int DRV_IRQ_Disable(void)
This is a semaphore function for nested disabling the interrupts.
Definition: netx_drv_cortex.h:154
gpio_app_gpio_app_cfg_mode_Msk
#define gpio_app_gpio_app_cfg_mode_Msk
Definition: netx90_app.h:47231
mmio_ctrl_Type::mmio_pio_oe_line_set_cfg0_b
struct mmio_ctrl_Type::@3869::@3899 mmio_pio_oe_line_set_cfg0_b
asic_ctrl_asic_ctrl_irq_raw_bod_fail_Pos
#define asic_ctrl_asic_ctrl_irq_raw_bod_fail_Pos
Definition: netx90_app.h:41047
gpio_app_Type::gpio_app_cfg
__IOM uint32_t gpio_app_cfg[8]
Definition: netx90_app.h:24609
DRV_DIO_MODE_CAPTURE_CONT_RISING
Definition: netx_drv_dio.h:82
DRV_PIO_DEVICE
#define DRV_PIO_DEVICE
Definition: netx_drv_csp_netx90_app.h:107
gpio_app_gpio_app_irq_mask_rst_gpio_app2_Msk
#define gpio_app_gpio_app_irq_mask_rst_gpio_app2_Msk
Definition: netx90_app.h:47339
PIO0_IRQHandler
void PIO0_IRQHandler(void)
Definition: netx_drv_dio.c:1670
hif_io_ctrl_hif_pio_irq_raw_irq_hif_a16_Msk
#define hif_io_ctrl_hif_pio_irq_raw_irq_hif_a16_Msk
Definition: netx90_app.h:41880
DRV_NSUPP
Definition: netx_drv_def.h:59
DRV_DIO_IRQ_COUNT
#define DRV_DIO_IRQ_COUNT
Definition: netx_drv_csp_netx90_app.h:119
DRV_DIO_MODE_CAPTURE_CONT_FALLING
Definition: netx_drv_dio.h:93
hif_io_ctrl_hif_pio_irq_raw_irq_hif_dirq_Msk
#define hif_io_ctrl_hif_pio_irq_raw_irq_hif_dirq_Msk
Definition: netx90_app.h:41876
DRV_DIO_LINE_MMIO
Definition: netx_drv_dio.h:61
DRV_DIO_GPIO5_Callback
void DRV_DIO_GPIO5_Callback(void)
This is the callback of the GPIO 5 IRQ.
Definition: netx_drv_dio.c:1509