git.sur5r.net Git - freertos/blob - Demo/CORTEX_A2F200_IAR_and_Keil/MicroSemi_Code/drivers/mss_ace/mss_ace.c

   1 /*******************************************************************************\r
   2  * (c) Copyright 2009 Actel Corporation.  All rights reserved.\r
   3  * \r
   4  * SVN $Revision: 2905 $\r
   5  * SVN $Date: 2010-08-20 14:03:28 +0100 (Fri, 20 Aug 2010) $\r
   6  */\r
   7 \r
   8 #include "mss_ace.h"\r
   9 #include "mtd_data.h"\r
  10 #include "envm_layout.h"\r
  11 #include "mss_ace_configurator.h"\r
  12 #include "../../CMSIS/a2fxxxm3.h"\r
  13 #include "../../CMSIS/mss_assert.h"\r
  14 #include "../../drivers_config/mss_ace/ace_config.h"\r
  15 #include <string.h>\r
  16 \r
  17 #ifdef __cplusplus\r
  18 extern "C" {\r
  19 #endif \r
  20 \r
  21 #define START_ADC_CONVERSION    0x80uL\r
  22 \r
  23 \r
  24 /**/\r
  25 void ace_init_flags( void );\r
  26 void ace_init_convert(void);\r
  27 \r
  28 /*-------------------------------------------------------------------------*//**\r
  29   See "mss_ace.h" for details of how to use this function.\r
  30  */\r
  31 void ACE_init( void )\r
  32 {\r
  33     /* Initialize driver's internal data. */\r
  34     ace_init_flags();\r
  35     \r
  36     /* Initialize the data structures used by conversion functions. */\r
  37     ace_init_convert();\r
  38 }\r
  39 \r
  40 /*-------------------------------------------------------------------------*//**\r
  41   See "mss_ace.h" for details of how to use this function.\r
  42  */\r
  43 void ACE_start_adc\r
  44 (\r
  45         adc_channel_id_t channel_id\r
  46 )\r
  47 {\r
  48     ACE->ADC0_CONV_CTRL = (uint32_t)channel_id | START_ADC_CONVERSION;\r
  49 }\r
  50 \r
  51 /*-------------------------------------------------------------------------*//**\r
  52   See "mss_ace.h" for details of how to use this function.\r
  53  */\r
  54 #define ADC_DATAVALID_MASK    0x00001000uL\r
  55 #define ADC_RESULT_MASK       0x00000FFFuL\r
  56 \r
  57 static const uint32_t volatile * const adc_status_reg_lut[NB_OF_ANALOG_MODULES] =\r
  58 {\r
  59     &ACE->ADC0_STATUS,\r
  60     &ACE->ADC1_STATUS,\r
  61     &ACE->ADC2_STATUS\r
  62 };\r
  63 \r
  64 uint16_t ACE_get_adc_result\r
  65 (\r
  66     uint8_t adc_id\r
  67 )\r
  68 {\r
  69     uint16_t result = 0u;\r
  70     uint32_t data_valid;\r
  71 \r
  72     ASSERT( adc_id < NB_OF_ANALOG_MODULES );\r
  73     \r
  74     if ( adc_id < (uint8_t)NB_OF_ANALOG_MODULES )\r
  75     {\r
  76         do {\r
  77             data_valid = *adc_status_reg_lut[adc_id] & ADC_DATAVALID_MASK;\r
  78         } while ( !data_valid );\r
  79         \r
  80         result = (uint16_t)(*adc_status_reg_lut[adc_id] & ADC_RESULT_MASK);\r
  81     }\r
  82     return result;\r
  83 }\r
  84 \r
  85 /*==============================================================================\r
  86  =========== Sigma Delta Digital to Analog Converters (SDD) Control ============\r
  87  =============================================================================*/\r
  88 \r
  89 #define SDD_ENABLE_MASK     0x20uL\r
  90 #define SDD_REG_SEL_MASK    0x40uL\r
  91  \r
  92 #define DAC0_SYNC_EN_MASK   0x10uL\r
  93 #define DAC1_SYNC_EN_MASK   0x20uL\r
  94 #define DAC2_SYNC_EN_MASK   0x40uL\r
  95 \r
  96 #define DAC0_SYNC_UPDATE    0x01uL\r
  97 #define DAC1_SYNC_UPDATE    0x02uL\r
  98 #define DAC2_SYNC_UPDATE    0x04uL\r
  99 \r
 100 /*-------------------------------------------------------------------------*//**\r
 101  *\r
 102  */\r
 103 static volatile uint32_t * const dac_ctrl_reg_lut[NB_OF_ANALOG_MODULES] =\r
 104 {\r
 105     &ACE->DAC0_CTRL,\r
 106     &ACE->DAC1_CTRL,\r
 107     &ACE->DAC1_CTRL\r
 108 };\r
 109 \r
 110 static const uint32_t dac_enable_masks_lut[NB_OF_ANALOG_MODULES] =\r
 111 {\r
 112     DAC0_SYNC_EN_MASK,\r
 113     DAC1_SYNC_EN_MASK,\r
 114     DAC2_SYNC_EN_MASK\r
 115 };\r
 116 \r
 117 static volatile uint32_t * const dac_byte01_reg_lut[NB_OF_ANALOG_MODULES] =\r
 118 {\r
 119     &ACE->SSE_DAC0_BYTES01,\r
 120     &ACE->SSE_DAC1_BYTES01,\r
 121     &ACE->SSE_DAC2_BYTES01,\r
 122 };\r
 123 \r
 124 static volatile uint32_t * const dac_byte2_reg_lut[NB_OF_ANALOG_MODULES] =\r
 125 {\r
 126     &ACE->DAC0_BYTE2,\r
 127     &ACE->DAC1_BYTE2,\r
 128     &ACE->DAC2_BYTE2\r
 129 };\r
 130 \r
 131 /*------------------------------------------------------------------------------\r
 132  * Pointer to the manufacturing test data containing trimming information\r
 133  * generated during manufacturing.\r
 134  */\r
 135 static const mtd_data_t * const p_mtd_data = (mtd_data_t *)MTD_ADDRESS;\r
 136 \r
 137 /*-------------------------------------------------------------------------*//**\r
 138   See "mss_ace.h" for details of how to use this function.\r
 139  */\r
 140 #define OBD_MODE_MASK       (uint8_t)0x01\r
 141 #define OBD_CHOPPING_MASK   (uint8_t)0x02\r
 142 \r
 143 void ACE_configure_sdd\r
 144 (\r
 145         sdd_id_t            sdd_id,\r
 146         sdd_resolution_t    resolution,\r
 147     uint8_t             mode,\r
 148     sdd_update_method_t sync_update\r
 149 )\r
 150 {\r
 151     ASSERT( sdd_id < NB_OF_SDD );\r
 152     \r
 153     if ( sdd_id < NB_OF_SDD )\r
 154     {\r
 155         const uint8_t sdd_2_quad_lut[NB_OF_SDD] = {0u, 2u, 4u};\r
 156         uint8_t quad_id;\r
 157         uint8_t obd_mode_idx = 1u;\r
 158         uint8_t chopping_mode_idx = 0u;\r
 159         uint32_t saved_pc2_ctrl;\r
 160         \r
 161         quad_id = sdd_2_quad_lut[sdd_id];\r
 162         \r
 163         /* Pause the SSE PC2 while accesses to ACB from APB3 are taking place. */\r
 164         saved_pc2_ctrl = ACE->PC2_CTRL;\r
 165         ACE->PC2_CTRL = 0u;\r
 166         \r
 167         /* Select between voltage/current and RTZ modes.*/\r
 168         ACE->ACB_DATA[quad_id].b6 = mode;\r
 169         \r
 170         /* Load manufacturing generated trim value. */\r
 171         if ( (mode & OBD_MODE_MASK) > 0u )\r
 172         {\r
 173             obd_mode_idx = 0u;\r
 174         }\r
 175         if ( (mode & OBD_CHOPPING_MASK) > 0u )\r
 176         {\r
 177             chopping_mode_idx = 1u;\r
 178         }\r
 179         ACE->ACB_DATA[quad_id].b4\r
 180             = p_mtd_data->odb_trimming[sdd_id][obd_mode_idx][chopping_mode_idx];\r
 181         \r
 182         /* Restore SSE PC2 operations since no ACB accesses should take place\r
 183          * beyond this point. */\r
 184         ACE->PC2_CTRL = saved_pc2_ctrl;\r
 185     \r
 186         /* Set SDD resolution. */\r
 187         *dac_ctrl_reg_lut[sdd_id] = (uint32_t)resolution;\r
 188         \r
 189         /* Update SDD value through SSE_DACn_BYTES01. */\r
 190         *dac_ctrl_reg_lut[sdd_id] |= SDD_REG_SEL_MASK;\r
 191         \r
 192         /* Synchronous or individual SDD update. */\r
 193         if ( INDIVIDUAL_UPDATE == sync_update )\r
 194         {\r
 195             ACE->DAC_SYNC_CTRL &= ~dac_enable_masks_lut[sdd_id];\r
 196         }\r
 197         else\r
 198         {\r
 199             ACE->DAC_SYNC_CTRL |= dac_enable_masks_lut[sdd_id];\r
 200         }\r
 201     }\r
 202 }\r
 203 \r
 204 /*-------------------------------------------------------------------------*//**\r
 205   See "mss_ace.h" for details of how to use this function.\r
 206  */\r
 207 void ACE_enable_sdd\r
 208 (\r
 209         sdd_id_t    sdd_id\r
 210 )\r
 211 {\r
 212     ASSERT( sdd_id < NB_OF_SDD );\r
 213     \r
 214     if ( sdd_id < NB_OF_SDD )\r
 215     {\r
 216         *dac_ctrl_reg_lut[sdd_id] |= SDD_ENABLE_MASK;\r
 217     }\r
 218 }\r
 219 \r
 220 /*-------------------------------------------------------------------------*//**\r
 221   See "mss_ace.h" for details of how to use this function.\r
 222  */\r
 223 void ACE_disable_sdd\r
 224 (\r
 225         sdd_id_t    sdd_id\r
 226 )\r
 227 {\r
 228     ASSERT( sdd_id < NB_OF_SDD );\r
 229     \r
 230     if ( sdd_id < NB_OF_SDD )\r
 231     {\r
 232         *dac_ctrl_reg_lut[sdd_id] &= ~SDD_ENABLE_MASK;\r
 233     }\r
 234 }\r
 235 \r
 236 /*-------------------------------------------------------------------------*//**\r
 237   See "mss_ace.h" for details of how to use this function.\r
 238  */\r
 239 void ACE_set_sdd_value\r
 240 (\r
 241         sdd_id_t    sdd_id,\r
 242         uint32_t    sdd_value\r
 243 )\r
 244 {\r
 245     ASSERT( sdd_id < NB_OF_SDD );\r
 246     \r
 247     if ( sdd_id < NB_OF_SDD )\r
 248     {\r
 249         *dac_byte2_reg_lut[sdd_id] = sdd_value >> 16;\r
 250         *dac_byte01_reg_lut[sdd_id] = sdd_value;\r
 251     }\r
 252 }\r
 253 \r
 254 /*-------------------------------------------------------------------------*//**\r
 255   See "mss_ace.h" for details of how to use this function.\r
 256  */\r
 257 void ACE_set_sdd_value_sync\r
 258 (\r
 259     uint32_t sdd0_value,\r
 260     uint32_t sdd1_value,\r
 261     uint32_t sdd2_value\r
 262 )\r
 263 {\r
 264     uint32_t dac_sync_ctrl;\r
 265     \r
 266     dac_sync_ctrl = ACE->DAC_SYNC_CTRL;\r
 267     \r
 268     if ( SDD_NO_UPDATE != sdd0_value )\r
 269     {\r
 270         ACE->DAC0_BYTE2 = sdd0_value >> 16;\r
 271         ACE->SSE_DAC0_BYTES01 = sdd0_value;\r
 272         dac_sync_ctrl |= DAC0_SYNC_UPDATE;\r
 273     }\r
 274 \r
 275     if ( SDD_NO_UPDATE != sdd1_value )\r
 276     {\r
 277         ACE->DAC1_BYTE2 = sdd1_value >> 16;\r
 278         ACE->SSE_DAC1_BYTES01 = sdd1_value;\r
 279         dac_sync_ctrl |= DAC1_SYNC_UPDATE;\r
 280     }\r
 281 \r
 282     if ( SDD_NO_UPDATE != sdd2_value )\r
 283     {\r
 284         ACE->DAC2_BYTE2 = sdd2_value >> 16;\r
 285         ACE->DAC2_BYTE1 = sdd2_value >> 8;\r
 286         ACE->SSE_DAC2_BYTES01 = sdd2_value;\r
 287         dac_sync_ctrl |= DAC2_SYNC_UPDATE;\r
 288     }\r
 289     \r
 290     ACE->DAC_SYNC_CTRL = dac_sync_ctrl;\r
 291 }\r
 292 \r
 293 /*==============================================================================\r
 294  ============================ Comparators Control ==============================\r
 295  =============================================================================*/\r
 296 \r
 297  /*\r
 298   * SDD Analog switch mask. ACB byte 10.\r
 299   *     0:  TMB comparator reference voltage is an ADC direct input\r
 300   *     1:  TMB comparator reference voltage is one of the SDD outputs as\r
 301   *         selected by DAC_MUXSEL[1:0]\r
 302   */\r
 303 #define B10_COMP_VREF_SW_MASK   0x20u\r
 304 \r
 305 /*\r
 306  * Comparator reference voltage multiplexer.\r
 307  * Used to select which SDD output will be used as reference voltage for TMB\r
 308  * comparator. These bits are only meaningful when COMP_VREF_SW is set to 1.\r
 309  */\r
 310 #define B11_DAC_MUXSEL_MASK     0x03u\r
 311 \r
 312 /*\r
 313  * Number of bits to shift a value of type comp_hysteresis_t to get the\r
 314  * hysteresis to program into ACB b9 or b10.\r
 315  */\r
 316 #define HYSTERESIS_SHIFT    6u\r
 317 \r
 318 /*\r
 319  * Mask of hysteresis bits within ACB b9 or b10.\r
 320  */\r
 321 #define HYSTERESIS_MASK     0xC0u\r
 322 \r
 323 /*\r
 324  * Mask of the comparator enable bit within ACB b9 and b10.\r
 325  */\r
 326 #define COMPARATOR_ENABLE_MASK  0x10u\r
 327 \r
 328 /*\r
 329  * Comparator ID to Signal Conditioning Block (SCB) lookup table.\r
 330  * USe to find which SCB a comparator belongs to.\r
 331  */\r
 332 const uint8_t comp_id_2_scb_lut[NB_OF_COMPARATORS] =\r
 333 {\r
 334     0u,  /* CMP0 */\r
 335     0u,  /* CMP1 */\r
 336     1u,  /* CMP2 */\r
 337     1u,  /* CMP3 */\r
 338     2u,  /* CMP4 */\r
 339     2u,  /* CMP5 */\r
 340     3u,  /* CMP6 */\r
 341     3u,  /* CMP7 */\r
 342     4u,  /* CMP8 */\r
 343     4u,  /* CMP9 */\r
 344     5u,  /* CMP10 */\r
 345     5u   /* CMP11 */\r
 346 };\r
 347 \r
 348 /*-------------------------------------------------------------------------*//**\r
 349  * This function is requred to configure comparators included in temperature\r
 350  * monitor blocks.\r
 351  */\r
 352 void ACE_set_comp_reference\r
 353 (\r
 354     comparator_id_t     comp_id,\r
 355     comp_reference_t    reference\r
 356 )\r
 357 {\r
 358     uint8_t scb_id;\r
 359     uint32_t odd;\r
 360     \r
 361     odd = (uint32_t)comp_id & 0x01uL;\r
 362     \r
 363     ASSERT( comp_id < NB_OF_COMPARATORS );\r
 364     ASSERT( reference < NB_OF_COMP_REF );\r
 365     ASSERT( odd );    /* Only Temperature block comparators have configurable reference input. */\r
 366     \r
 367     if ( (comp_id < NB_OF_COMPARATORS) && (reference < NB_OF_COMP_REF) && (odd) )\r
 368     {\r
 369         uint32_t saved_pc2_ctrl;\r
 370         \r
 371         scb_id = comp_id_2_scb_lut[comp_id];\r
 372         \r
 373         /* Pause the SSE PC2 while accesses to ACB from APB3 are taking place. */\r
 374         saved_pc2_ctrl = ACE->PC2_CTRL;\r
 375         ACE->PC2_CTRL = 0u;\r
 376     \r
 377         if ( ADC_IN_COMP_REF == reference )\r
 378         {\r
 379             ACE->ACB_DATA[scb_id].b10 &= (uint8_t)~B10_COMP_VREF_SW_MASK;\r
 380             ACE->ACB_DATA[scb_id].b11 &= (uint8_t)~B11_DAC_MUXSEL_MASK;\r
 381         }\r
 382         else\r
 383         {\r
 384             ACE->ACB_DATA[scb_id].b10 &= (uint8_t)~B10_COMP_VREF_SW_MASK;\r
 385             ACE->ACB_DATA[scb_id].b11 = (ACE->ACB_DATA[scb_id].b11 & (uint8_t)~B11_DAC_MUXSEL_MASK) + (uint8_t)reference;\r
 386         }\r
 387     \r
 388         /* Restore SSE PC2 operations since no ACB accesses should take place\r
 389          * beyond this point. */\r
 390         ACE->PC2_CTRL = saved_pc2_ctrl;\r
 391     }\r
 392 }\r
 393 \r
 394 /*-------------------------------------------------------------------------*//**\r
 395  * Set analog block comparators hysteresis.\r
 396  */\r
 397 void ACE_set_comp_hysteresis\r
 398 (\r
 399         comparator_id_t     comp_id,\r
 400     comp_hysteresis_t   hysteresis\r
 401 )\r
 402 {\r
 403     uint8_t scb_id;\r
 404     \r
 405     ASSERT( comp_id < NB_OF_COMPARATORS );\r
 406     ASSERT( hysteresis < NB_OF_HYSTERESIS );\r
 407     \r
 408     if ( (comp_id < NB_OF_COMPARATORS) && (hysteresis < NB_OF_HYSTERESIS) )\r
 409     {\r
 410         uint32_t odd;\r
 411         uint32_t saved_pc2_ctrl;\r
 412         \r
 413         scb_id = comp_id_2_scb_lut[comp_id];\r
 414         odd = (uint32_t)comp_id & 0x01uL;\r
 415         \r
 416         /* Pause the SSE PC2 while accesses to ACB from APB3 are taking place. */\r
 417         saved_pc2_ctrl = ACE->PC2_CTRL;\r
 418         ACE->PC2_CTRL = 0u;\r
 419     \r
 420         if ( odd )\r
 421         {\r
 422             /* Temperature monitor block comparator. */\r
 423             ACE->ACB_DATA[scb_id].b10 = (ACE->ACB_DATA[scb_id].b10 & HYSTERESIS_MASK) | (uint8_t)((uint8_t)hysteresis << HYSTERESIS_SHIFT);\r
 424         }\r
 425         else\r
 426         {\r
 427             /* Current monitor block comparator. */\r
 428             ACE->ACB_DATA[scb_id].b9 = (ACE->ACB_DATA[scb_id].b9 & HYSTERESIS_MASK) | (uint8_t)((uint8_t)hysteresis << HYSTERESIS_SHIFT);\r
 429         }\r
 430         \r
 431         /* Restore SSE PC2 operations since no ACB accesses should take place\r
 432          * beyond this point. */\r
 433         ACE->PC2_CTRL = saved_pc2_ctrl;\r
 434     }\r
 435 }\r
 436 \r
 437 /*-------------------------------------------------------------------------*//**\r
 438   \r
 439  */\r
 440 void ACE_enable_comp\r
 441 (\r
 442         comparator_id_t comp_id\r
 443 )\r
 444 {\r
 445     uint8_t scb_id;\r
 446     \r
 447     ASSERT( comp_id < NB_OF_COMPARATORS );\r
 448     \r
 449     if ( comp_id < NB_OF_COMPARATORS )\r
 450     {\r
 451         uint32_t odd;\r
 452         uint32_t saved_pc2_ctrl;\r
 453         \r
 454         scb_id = comp_id_2_scb_lut[comp_id];\r
 455         odd = (uint32_t)comp_id & 0x01uL;\r
 456         \r
 457         /* Pause the SSE PC2 while accesses to ACB from APB3 are taking place. */\r
 458         saved_pc2_ctrl = ACE->PC2_CTRL;\r
 459         ACE->PC2_CTRL = 0u;\r
 460         \r
 461         if ( odd )\r
 462         {\r
 463             /* Temperature monitor block comparator. */\r
 464             ACE->ACB_DATA[scb_id].b10 |= COMPARATOR_ENABLE_MASK;\r
 465         }\r
 466         else\r
 467         {\r
 468             /* Current monitor block comparator. */\r
 469             ACE->ACB_DATA[scb_id].b9 |= COMPARATOR_ENABLE_MASK;\r
 470         }\r
 471         \r
 472         /* Restore SSE PC2 operations since no ACB accesses should take place\r
 473          * beyond this point. */\r
 474         ACE->PC2_CTRL = saved_pc2_ctrl;\r
 475     }\r
 476 }\r
 477 \r
 478 /*-------------------------------------------------------------------------*//**\r
 479  *\r
 480  */\r
 481 void ACE_disable_comp\r
 482 (\r
 483         comparator_id_t comp_id\r
 484 )\r
 485 {\r
 486     uint8_t scb_id;\r
 487     \r
 488     ASSERT( comp_id < NB_OF_COMPARATORS );\r
 489     \r
 490     if ( comp_id < NB_OF_COMPARATORS )\r
 491     {\r
 492         uint32_t odd;\r
 493         uint32_t saved_pc2_ctrl;\r
 494         \r
 495         scb_id = comp_id_2_scb_lut[comp_id];\r
 496         odd = (uint32_t)comp_id & 0x01uL;\r
 497         \r
 498         /* Pause the SSE PC2 while accesses to ACB from APB3 are taking place. */\r
 499         saved_pc2_ctrl = ACE->PC2_CTRL;\r
 500         ACE->PC2_CTRL = 0u;\r
 501         \r
 502         if ( odd )\r
 503         {\r
 504             /* Temperature monitor block comparator. */\r
 505             ACE->ACB_DATA[scb_id].b10 &= (uint8_t)~COMPARATOR_ENABLE_MASK;\r
 506         }\r
 507         else\r
 508         {\r
 509             /* Current monitor block comparator. */\r
 510             ACE->ACB_DATA[scb_id].b9 &= (uint8_t)~COMPARATOR_ENABLE_MASK;\r
 511         }\r
 512         \r
 513         /* Restore SSE PC2 operations since no ACB accesses should take place\r
 514          * beyond this point. */\r
 515         ACE->PC2_CTRL = saved_pc2_ctrl;\r
 516     }\r
 517 }\r
 518 \r
 519 /*\r
 520  * Bit mask of comparator 0 rise interrupt bit.\r
 521  * Shift this value left by the value of the comparator ID to obtain the bit\r
 522  * mask used enable/disable/clear rise interrupts from that comparator.\r
 523  */\r
 524 #define FIRST_RISE_IRQ_MASK     0x00000800uL\r
 525 \r
 526 /*\r
 527  * Bit mask of comparator 0 fall interrupt bit.\r
 528  * Shift this value left by the value of the comparator ID to obtain the bit\r
 529  * mask used enable/disable/clear fall interrupts from that comparator.\r
 530  */\r
 531 #define FIRST_FALL_IRQ_MASK     0x00000001uL\r
 532 \r
 533 /*-------------------------------------------------------------------------*//**\r
 534   See "mss_ace.h" for details of how to use this function.\r
 535  */\r
 536 void ACE_enable_comp_rise_irq\r
 537 (\r
 538         comparator_id_t comp_id\r
 539 )\r
 540 {\r
 541     ASSERT( comp_id < NB_OF_COMPARATORS );\r
 542     \r
 543     ACE->COMP_IRQ_EN |= (FIRST_RISE_IRQ_MASK << (uint32_t)comp_id);\r
 544 }\r
 545 \r
 546 /*-------------------------------------------------------------------------*//**\r
 547   See "mss_ace.h" for details of how to use this function.\r
 548  */\r
 549 void ACE_disable_comp_rise_irq\r
 550 (\r
 551         comparator_id_t comp_id\r
 552 )\r
 553 {\r
 554     ASSERT( comp_id < NB_OF_COMPARATORS );\r
 555     \r
 556     ACE->COMP_IRQ_EN &= ~(FIRST_RISE_IRQ_MASK << (uint32_t)comp_id);\r
 557 }\r
 558 \r
 559 /*-------------------------------------------------------------------------*//**\r
 560   See "mss_ace.h" for details of how to use this function.\r
 561  */\r
 562 void ACE_clear_comp_rise_irq\r
 563 (\r
 564         comparator_id_t comp_id\r
 565 )\r
 566 {\r
 567     ASSERT( comp_id < NB_OF_COMPARATORS );\r
 568     \r
 569     ACE->COMP_IRQ_CLR |= (FIRST_RISE_IRQ_MASK << (uint32_t)comp_id);\r
 570 }\r
 571 \r
 572 /*-------------------------------------------------------------------------*//**\r
 573   See "mss_ace.h" for details of how to use this function.\r
 574  */\r
 575 void ACE_enable_comp_fall_irq\r
 576 (\r
 577         comparator_id_t comp_id\r
 578 )\r
 579 {\r
 580     ASSERT( comp_id < NB_OF_COMPARATORS );\r
 581     \r
 582     ACE->COMP_IRQ_EN |= (FIRST_FALL_IRQ_MASK << (uint32_t)comp_id);\r
 583 }\r
 584 \r
 585 /*-------------------------------------------------------------------------*//**\r
 586   See "mss_ace.h" for details of how to use this function.\r
 587  */\r
 588 void ACE_disable_comp_fall_irq\r
 589 (\r
 590         comparator_id_t comp_id\r
 591 )\r
 592 {\r
 593     ASSERT( comp_id < NB_OF_COMPARATORS );\r
 594     \r
 595     ACE->COMP_IRQ_EN &= ~(FIRST_FALL_IRQ_MASK << (uint32_t)comp_id);\r
 596 }\r
 597 \r
 598 /*-------------------------------------------------------------------------*//**\r
 599   See "mss_ace.h" for details of how to use this function.\r
 600  */\r
 601 void ACE_clear_comp_fall_irq\r
 602 (\r
 603         comparator_id_t comp_id\r
 604 )\r
 605 {\r
 606     ASSERT( comp_id < NB_OF_COMPARATORS );\r
 607     \r
 608     ACE->COMP_IRQ_CLR |= (FIRST_FALL_IRQ_MASK << (uint32_t)comp_id);\r
 609 }\r
 610 \r
 611 /*-------------------------------------------------------------------------*//**\r
 612  * Returns the raw analog quad comparator status.\r
 613  */\r
 614 uint32_t ACE_get_comp_status( void )\r
 615 {\r
 616     return ACE->COMP_IRQ;\r
 617 }\r
 618 \r
 619 /*==============================================================================\r
 620  ============ Reading Samples from post processing engine (PPE) ================\r
 621  =============================================================================*/\r
 622 extern ace_channel_desc_t g_ace_channel_desc_table[ACE_NB_OF_INPUT_CHANNELS];\r
 623 \r
 624 /*-------------------------------------------------------------------------*//**\r
 625   See "mss_ace.h" for details of how to use this function.\r
 626  */\r
 627 uint32_t\r
 628 ACE_get_channel_count\r
 629 (\r
 630     void\r
 631 )\r
 632 {\r
 633     return (uint32_t)ACE_NB_OF_INPUT_CHANNELS;\r
 634 }\r
 635 \r
 636 /*-------------------------------------------------------------------------*//**\r
 637   See "mss_ace.h" for details of how to use this function.\r
 638  */\r
 639 ace_channel_handle_t\r
 640 ACE_get_first_channel\r
 641 (\r
 642     void\r
 643 )\r
 644 {\r
 645     ace_channel_handle_t channel_handle;\r
 646     \r
 647     channel_handle = (ace_channel_handle_t)0;\r
 648     \r
 649     return channel_handle;\r
 650 }\r
 651 \r
 652 /*-------------------------------------------------------------------------*//**\r
 653   See "mss_ace.h" for details of how to use this function.\r
 654  */\r
 655 ace_channel_handle_t\r
 656 ACE_get_next_channel\r
 657 (\r
 658     ace_channel_handle_t channel_handle\r
 659 )\r
 660 {\r
 661     ++channel_handle;\r
 662     \r
 663     if ( channel_handle >= NB_OF_ACE_CHANNEL_HANDLES )\r
 664     {\r
 665          channel_handle = (ace_channel_handle_t)0;\r
 666     }\r
 667     \r
 668     return channel_handle;\r
 669 }\r
 670 \r
 671 /*-------------------------------------------------------------------------*//**\r
 672   See "mss_ace.h" for details of how to use this function.\r
 673  */\r
 674 ace_channel_handle_t\r
 675 ACE_get_channel_handle\r
 676 (\r
 677     const uint8_t * p_sz_channel_name\r
 678 )\r
 679 {\r
 680     uint16_t channel_idx;\r
 681     ace_channel_handle_t channel_handle = INVALID_CHANNEL_HANDLE;\r
 682     \r
 683     for ( channel_idx = 0u;  channel_idx < (uint16_t)ACE_NB_OF_INPUT_CHANNELS; ++channel_idx )\r
 684     {\r
 685         if ( g_ace_channel_desc_table[channel_idx].p_sz_channel_name != 0 )\r
 686         {\r
 687             int32_t diff;\r
 688             diff = strncmp( (const char*)p_sz_channel_name, (const char*)g_ace_channel_desc_table[channel_idx].p_sz_channel_name, MAX_CHANNEL_NAME_LENGTH );\r
 689             if ( 0 == diff )\r
 690             {\r
 691                 /* channel name found. */\r
 692                 channel_handle = (ace_channel_handle_t)channel_idx;\r
 693                 break;\r
 694             }\r
 695         }\r
 696     }\r
 697     return channel_handle;\r
 698 }\r
 699 \r
 700 /*-------------------------------------------------------------------------*//**\r
 701   See "mss_ace.h" for details of how to use this function.\r
 702  */\r
 703 ace_channel_handle_t\r
 704 ACE_get_input_channel_handle\r
 705 (\r
 706     adc_channel_id_t    channel_id\r
 707 )\r
 708 {\r
 709     uint16_t channel_idx;\r
 710     ace_channel_handle_t channel_handle = INVALID_CHANNEL_HANDLE;\r
 711     \r
 712     for ( channel_idx = 0u;  channel_idx < (uint16_t)ACE_NB_OF_INPUT_CHANNELS; ++channel_idx )\r
 713     {\r
 714         if ( g_ace_channel_desc_table[channel_idx].signal_id == channel_id )\r
 715         {\r
 716             /* channel ID found. */\r
 717             channel_handle = (ace_channel_handle_t)channel_idx;\r
 718             break;\r
 719         }\r
 720     }\r
 721     return channel_handle;\r
 722 }\r
 723 \r
 724 /*-------------------------------------------------------------------------*//**\r
 725   See "mss_ace.h" for details of how to use this function.\r
 726  */\r
 727 uint16_t\r
 728 ACE_get_ppe_sample\r
 729 (\r
 730     ace_channel_handle_t channel_handle\r
 731 )\r
 732 {\r
 733     uint16_t sample;\r
 734     uint16_t ppe_offset;\r
 735     \r
 736     ppe_offset = g_ace_channel_desc_table[channel_handle].signal_ppe_offset;\r
 737     sample = (uint16_t)(ACE->PPE_RAM_DATA[ppe_offset] >> 16u);\r
 738     \r
 739     return sample;\r
 740 }\r
 741 \r
 742 #ifdef __cplusplus\r
 743 }\r
 744 #endif\r