arch/ppc/mpc55xx/drivers/Adc.c

   1 /* -------------------------------- Arctic Core ------------------------------\r
   2  * Arctic Core - the open source AUTOSAR platform http://arccore.com\r
   3  *\r
   4  * Copyright (C) 2009  ArcCore AB <contact@arccore.com>\r
   5  *\r
   6  * This source code is free software; you can redistribute it and/or modify it\r
   7  * under the terms of the GNU General Public License version 2 as published by the\r
   8  * Free Software Foundation; See <http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt>.\r
   9  *\r
  10  * This program is distributed in the hope that it will be useful, but\r
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\r
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
  13  * for more details.\r
  14  * -------------------------------- Arctic Core ------------------------------*/\r
  15 \r
  16 #include <assert.h>\r
  17 #include <stdlib.h>\r
  18 //#include "System.h"\r
  19 #include "mpc55xx.h"\r
  20 #include "Modules.h"\r
  21 #include "Mcu.h"\r
  22 #include "Adc.h"\r
  23 #include "Det.h"\r
  24 #include "Os.h"\r
  25 #include "isr.h"\r
  26 #include "irq.h"\r
  27 #include "arc.h"\r
  28 \r
  29 /* Uncomment and use DMA for 5606 only if you now what you are doing */\r
  30 #define DONT_USE_DMA_IN_ADC_MPC560X\r
  31 \r
  32 /* Are we gonna use Dma? */\r
  33 #if ( !defined(CFG_MPC560X) || \\r
  34       ( defined(CFG_MPC5606S) && !defined(DONT_USE_DMA_IN_ADC_MPC560X) ) )\r
  35         #define ADC_USES_DMA\r
  36         #include "Dma.h"\r
  37 #endif\r
  38 \r
  39 #if ( defined(ADC_USES_DMA) && !defined(USE_DMA) )\r
  40         #error Adc is configured to use Dma but the module is not enabled.\r
  41 #endif\r
  42 \r
  43 #define ADC_GROUP0              0\r
  44 \r
  45 #if !defined(CFG_MPC560X)\r
  46 typedef union\r
  47 {\r
  48   vuint32_t R;\r
  49   struct\r
  50   {\r
  51     vuint32_t EOQ:1;\r
  52     vuint32_t PAUSE:1;\r
  53     vuint32_t :4;\r
  54     vuint32_t BN:1;\r
  55     vuint32_t RW:1;\r
  56     vuint32_t ADC_REG:16;\r
  57     vuint32_t ADC_REG_ADDR:8;\r
  58    } B;\r
  59 }Adc_RegisterWriteType;\r
  60 \r
  61 typedef union\r
  62 {\r
  63   vuint32_t R;\r
  64   struct\r
  65   {\r
  66     vuint32_t EOQ:1;\r
  67     vuint32_t PAUSE:1;\r
  68     vuint32_t :4;\r
  69     vuint32_t BN:1;\r
  70     vuint32_t RW:1;\r
  71     vuint32_t MESSAGE_TAG:4;\r
  72     vuint32_t :12;\r
  73     vuint32_t ADC_REG_ADDR:8;\r
  74    } B;\r
  75 }Adc_RegisterReadType;\r
  76 \r
  77 typedef enum\r
  78 {\r
  79   ADC_EQADC_QUEUE_0,\r
  80   ADC_EQADC_QUEUE_1,\r
  81   ADC_EQADC_QUEUE_2,\r
  82   ADC_EQADC_QUEUE_3,\r
  83   ADC_EQADC_QUEUE_4,\r
  84   ADC_EQADC_QUEUE_5,\r
  85   ADC_EQADC_NBR_OF_QUEUES\r
  86 }Adc_eQADCQueueType;\r
  87 \r
  88 typedef enum\r
  89 {\r
  90   EQADC_CFIFO_STATUS_IDLE = 0,\r
  91   EQADC_CFIFO_STATUS_WAITINGFOR_TRIGGER = 0x2,\r
  92   EQADC_CFIFO_STATUS_TRIGGERED = 0x3\r
  93 }Adc_EQADCQueueStatusType;\r
  94 \r
  95 typedef int16_t Adc_EQADCRegister;\r
  96 \r
  97 typedef enum\r
  98 {\r
  99   ADC0_CR = 1,\r
 100   ADC0_TSCR,\r
 101   ADC0_TBCR,\r
 102   ADC0_GCCR,\r
 103   ADC0_OCCR\r
 104 }Adc_EQADCRegisterType;\r
 105 \r
 106 /* Command queue for calibration sequence. See 31.5.6 in reference manual. */\r
 107 const Adc_CommandType AdcCalibrationCommandQueue [] =\r
 108 {\r
 109   /* Four samples of 25 % of (VRh - VRl). */\r
 110   {\r
 111         .B.EOQ = 0, .B.PAUSE = 0, .B.BN = 0, .B.CAL = 0, .B.MESSAGE_TAG = 0, .B.LST = ADC_CONVERSION_TIME_128_CLOCKS, .B.TSR = 0, .B.FMT = 0,\r
 112         .B.CHANNEL_NUMBER = 44\r
 113   },\r
 114   {\r
 115     .B.EOQ = 0, .B.PAUSE = 0, .B.BN = 0, .B.CAL = 0, .B.MESSAGE_TAG = 0, .B.LST = ADC_CONVERSION_TIME_128_CLOCKS, .B.TSR = 0, .B.FMT = 0,\r
 116     .B.CHANNEL_NUMBER = 44\r
 117   },\r
 118   {\r
 119     .B.EOQ = 0, .B.PAUSE = 0, .B.BN = 0, .B.CAL = 0, .B.MESSAGE_TAG = 0, .B.LST = ADC_CONVERSION_TIME_128_CLOCKS, .B.TSR = 0, .B.FMT = 0,\r
 120     .B.CHANNEL_NUMBER = 44\r
 121   },\r
 122   {\r
 123     .B.EOQ = 0, .B.PAUSE = 0, .B.BN = 0, .B.CAL = 0, .B.MESSAGE_TAG = 0, .B.LST = ADC_CONVERSION_TIME_128_CLOCKS, .B.TSR = 0, .B.FMT = 0,\r
 124     .B.CHANNEL_NUMBER = 44\r
 125   },\r
 126   /* Four samples of 75 % of (VRh - VRl). */\r
 127   {\r
 128     .B.EOQ = 0, .B.PAUSE = 0, .B.BN = 0, .B.CAL = 0, .B.MESSAGE_TAG = 0, .B.LST = ADC_CONVERSION_TIME_128_CLOCKS, .B.TSR = 0, .B.FMT = 0,\r
 129     .B.CHANNEL_NUMBER = 43\r
 130   },\r
 131   {\r
 132     .B.EOQ = 0, .B.PAUSE = 0, .B.BN = 0, .B.CAL = 0, .B.MESSAGE_TAG = 0, .B.LST = ADC_CONVERSION_TIME_128_CLOCKS, .B.TSR = 0, .B.FMT = 0,\r
 133     .B.CHANNEL_NUMBER = 43\r
 134   },\r
 135   {\r
 136     .B.EOQ = 0, .B.PAUSE = 0, .B.BN = 0, .B.CAL = 0, .B.MESSAGE_TAG = 0, .B.LST = ADC_CONVERSION_TIME_128_CLOCKS, .B.TSR = 0, .B.FMT = 0,\r
 137     .B.CHANNEL_NUMBER = 43\r
 138   },\r
 139   {\r
 140     .B.EOQ = 1, .B.PAUSE = 0, .B.BN = 0, .B.CAL = 0, .B.MESSAGE_TAG = 0, .B.LST = ADC_CONVERSION_TIME_128_CLOCKS, .B.TSR = 0, .B.FMT = 0,\r
 141     .B.CHANNEL_NUMBER = 43\r
 142   }\r
 143 };\r
 144 \r
 145 /* DMA configuration for calibration sequence. */\r
 146 const Dma_TcdType AdcCalibrationDMACommandConfig =\r
 147 {\r
 148   .SADDR = (uint32_t)AdcCalibrationCommandQueue,\r
 149   .SMOD = 0,\r
 150   .SSIZE = DMA_TRANSFER_SIZE_32BITS,\r
 151   .DMOD = 0,\r
 152   .DSIZE = DMA_TRANSFER_SIZE_32BITS,\r
 153   .SOFF = sizeof(Adc_CommandType),\r
 154   .NBYTESu.B.NBYTES = sizeof(Adc_CommandType),\r
 155   .SLAST = 0,\r
 156   .DADDR = (vint32_t)&EQADC.CFPR[0].R,\r
 157   .CITERE_LINK = 0,\r
 158   .CITER = 0,\r
 159   .DOFF = 0,\r
 160   .DLAST_SGA = 0,\r
 161   .BITERE_LINK = 0,\r
 162   .BITER = 0,\r
 163   .BWC = 0,\r
 164   .MAJORLINKCH = 0,\r
 165   .DONE = 0,\r
 166   .ACTIVE = 0,\r
 167   .MAJORE_LINK = 0,\r
 168   .E_SG = 0,\r
 169   .D_REQ = 0,\r
 170   .INT_HALF = 0,\r
 171   .INT_MAJ = 0,\r
 172   .START = 0,\r
 173 };\r
 174 \r
 175 const Dma_TcdType AdcCalibrationDMAResultConfig =\r
 176 {\r
 177   .SADDR = (vint32_t)&EQADC.RFPR[0].R + 2,\r
 178   .SMOD = 0,\r
 179   .SSIZE = DMA_TRANSFER_SIZE_16BITS,\r
 180   .DMOD = 0,\r
 181   .DSIZE = DMA_TRANSFER_SIZE_16BITS,\r
 182   .SOFF = 0,\r
 183   .NBYTESu.B.NBYTES = sizeof(Adc_ValueGroupType),\r
 184   .SLAST = 0,\r
 185   .DADDR = 0, /* Dynamic address, written later. */\r
 186   .CITERE_LINK = 0,\r
 187   .CITER = 0,\r
 188   .DOFF = sizeof(Adc_ValueGroupType),\r
 189   .DLAST_SGA = 0,\r
 190   .BITERE_LINK = 0,\r
 191   .BITER = 0,\r
 192   .BWC = 0,\r
 193   .MAJORLINKCH = 0,\r
 194   .DONE = 0,\r
 195   .ACTIVE = 0,\r
 196   .MAJORE_LINK = 0,\r
 197   .E_SG = 0,\r
 198   .D_REQ = 0,\r
 199   .INT_HALF = 0,\r
 200   .INT_MAJ = 0,\r
 201   .START = 0\r
 202 };\r
 203 #endif\r
 204 \r
 205 typedef enum\r
 206 {\r
 207   ADC_UNINIT,\r
 208   ADC_INIT,\r
 209 }Adc_StateType;\r
 210 \r
 211 /* Function prototypes. */\r
 212 #if defined(CFG_MPC560X)\r
 213 static void Adc_ConfigureADC (const Adc_ConfigType *ConfigPtr);\r
 214 static void Adc_ConfigureADCInterrupts (void);\r
 215 #else\r
 216 static void Adc_ConfigureEQADC (const Adc_ConfigType *ConfigPtr);\r
 217 static void Adc_ConfigureEQADCInterrupts (void);\r
 218 static void Adc_EQADCCalibrationSequence (void);\r
 219 static void Adc_WriteEQADCRegister (Adc_EQADCRegisterType reg, Adc_EQADCRegister value);\r
 220 static Adc_EQADCRegister Adc_ReadEQADCRegister (Adc_EQADCRegisterType reg);\r
 221 #endif\r
 222 \r
 223 void Adc_GroupConversionComplete (Adc_GroupType group);\r
 224 \r
 225 /* Development error checking. */\r
 226 static Std_ReturnType Adc_CheckReadGroup (Adc_GroupType group);\r
 227 static Std_ReturnType Adc_CheckStartGroupConversion (Adc_GroupType group);\r
 228 static Std_ReturnType Adc_CheckStopGroupConversion (Adc_GroupType group);\r
 229 static Std_ReturnType Adc_CheckInit (const Adc_ConfigType *ConfigPtr);\r
 230 #if (ADC_DEINIT_API == STD_ON)\r
 231 static Std_ReturnType Adc_CheckDeInit (void);\r
 232 #endif\r
 233 static Std_ReturnType Adc_CheckSetupResultBuffer (Adc_GroupType group);\r
 234 static Std_ReturnType Adc_CheckGetStreamLastPointer (Adc_GroupType group);\r
 235 \r
 236 /* static variable declarations */\r
 237 static Adc_StateType adcState = ADC_UNINIT;\r
 238 static const Adc_ConfigType *AdcConfigPtr;      /* Pointer to configuration structure. */\r
 239 \r
 240 /* Validate functions used for development error check */\r
 241 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
 242 Std_ReturnType ValidateInit(Adc_APIServiceIDType api)\r
 243 {\r
 244         Std_ReturnType res = E_OK;\r
 245         if(!(ADC_INIT == adcState)) {\r
 246                 Det_ReportError(MODULE_ID_ADC,0,api,ADC_E_UNINIT );\r
 247                 res = E_NOT_OK;\r
 248         }\r
 249         return res;\r
 250 }\r
 251 Std_ReturnType ValidateGroup(Adc_GroupType group,Adc_APIServiceIDType api)\r
 252 {\r
 253         Std_ReturnType res = E_OK;\r
 254         if(!((group >= 0) && (group < AdcConfig->nbrOfGroups))) {\r
 255                 Det_ReportError(MODULE_ID_ADC,0,api,ADC_E_PARAM_GROUP );\r
 256                 res = E_NOT_OK;\r
 257         }\r
 258         return res;\r
 259 }\r
 260 #endif\r
 261 \r
 262 #if (ADC_DEINIT_API == STD_ON)\r
 263 Std_ReturnType Adc_DeInit (const Adc_ConfigType *ConfigPtr)\r
 264 {\r
 265   (void)ConfigPtr;\r
 266 #if defined(CFG_MPC560X)\r
 267 \r
 268   if (E_OK == Adc_CheckDeInit())\r
 269   {\r
 270     for(Adc_GroupType group = ADC_GROUP0; group < AdcConfigPtr->nbrOfGroups; group++)\r
 271     {\r
 272       /* Set group status to idle. */\r
 273       AdcConfigPtr->groupConfigPtr[group].status->groupStatus = ADC_IDLE;\r
 274     }\r
 275 \r
 276     /* Disable DMA transfer*/\r
 277 #ifndef CFG_MPC5604B\r
 278     ADC_0.DMAE.B.DMAEN = 0;\r
 279 #endif\r
 280     /* Power down ADC */\r
 281     ADC_0.MCR.R = 0x0001;\r
 282 \r
 283     /* Disable all interrupt*/\r
 284     ADC_0.IMR.R = 0;\r
 285 \r
 286     /* Clean internal status. */\r
 287     AdcConfigPtr = (Adc_ConfigType *)NULL;\r
 288     adcState = ADC_UNINIT;\r
 289   }\r
 290 \r
 291   return (E_OK);\r
 292     \r
 293 #else\r
 294 \r
 295   Adc_eQADCQueueType queue;\r
 296   Adc_GroupType group;\r
 297   boolean queueStopped;\r
 298 \r
 299   if (E_OK == Adc_CheckDeInit())\r
 300   {\r
 301     /* Stop all queues. */\r
 302     for (queue = ADC_EQADC_QUEUE_0; queue < ADC_EQADC_NBR_OF_QUEUES; queue++)\r
 303     {\r
 304       /* Disable queue. */\r
 305       EQADC.CFCR[queue].B.MODE = 0;\r
 306 \r
 307       /* Wait for queue to enter idle state. */\r
 308       queueStopped = FALSE;\r
 309       /* TODO replace switch with bit pattern. */\r
 310       while (!queueStopped)\r
 311       {\r
 312         switch (queue)\r
 313         {\r
 314         case ADC_EQADC_QUEUE_0:\r
 315           queueStopped = (EQADC.CFSR.B.CFS0 == EQADC_CFIFO_STATUS_IDLE);\r
 316           break;\r
 317         case ADC_EQADC_QUEUE_1:\r
 318           queueStopped = (EQADC.CFSR.B.CFS1 == EQADC_CFIFO_STATUS_IDLE);\r
 319           break;\r
 320         case ADC_EQADC_QUEUE_2:\r
 321           queueStopped = (EQADC.CFSR.B.CFS2 == EQADC_CFIFO_STATUS_IDLE);\r
 322           break;\r
 323         case ADC_EQADC_QUEUE_3:\r
 324           queueStopped = (EQADC.CFSR.B.CFS3 == EQADC_CFIFO_STATUS_IDLE);\r
 325           break;\r
 326         case ADC_EQADC_QUEUE_4:\r
 327           queueStopped = (EQADC.CFSR.B.CFS4 == EQADC_CFIFO_STATUS_IDLE);\r
 328           break;\r
 329         case ADC_EQADC_QUEUE_5:\r
 330           queueStopped = (EQADC.CFSR.B.CFS5 == EQADC_CFIFO_STATUS_IDLE);\r
 331           break;\r
 332         default :\r
 333           /* We should never get here... Terminate loop. */\r
 334           queueStopped = TRUE;\r
 335           break;\r
 336         }\r
 337       }\r
 338 \r
 339       /* Disable eDMA requests for commands and results. */\r
 340       EQADC.IDCR[queue].B.CFFS = 0;\r
 341       EQADC.IDCR[queue].B.RFDS = 0;\r
 342 \r
 343       /* Disable FIFO fill requests. */\r
 344       EQADC.IDCR[queue].B.CFFE = 0;\r
 345       EQADC.IDCR[queue].B.RFDE = 0;\r
 346 \r
 347       /* Disable interrupts. */\r
 348       EQADC.IDCR[queue].B.RFOIE = 0;\r
 349       EQADC.IDCR[queue].B.CFUIE = 0;\r
 350       EQADC.IDCR[queue].B.TORIE = 0;\r
 351       EQADC.IDCR[queue].B.EOQIE = 0;\r
 352     }\r
 353 \r
 354     /* Stop all DMA channels connected to EQADC. */\r
 355     for (group = ADC_GROUP0; group < AdcConfigPtr->nbrOfGroups; group++)\r
 356     {\r
 357       Dma_StopChannel (AdcConfigPtr->groupConfigPtr [group].dmaCommandChannel);\r
 358       Dma_StopChannel (AdcConfigPtr->groupConfigPtr [group].dmaResultChannel);\r
 359 \r
 360       /* Set group status to idle. */\r
 361       AdcConfigPtr->groupConfigPtr[group].status->groupStatus = ADC_IDLE;\r
 362     }\r
 363 \r
 364     /* Disable EQADC. */\r
 365     Adc_WriteEQADCRegister (ADC0_CR, 0);\r
 366 \r
 367     /* Clean internal status. */\r
 368     AdcConfigPtr = (Adc_ConfigType *)NULL;\r
 369     adcState = ADC_UNINIT;\r
 370   }\r
 371   return (E_OK);\r
 372 #endif /* ENDOF defined(CFG_MPC560X) */\r
 373 }\r
 374 #endif\r
 375 \r
 376 Std_ReturnType Adc_Init (const Adc_ConfigType *ConfigPtr)\r
 377 {\r
 378 #if defined(CFG_MPC560X)\r
 379 \r
 380   if (E_OK == Adc_CheckInit(ConfigPtr))\r
 381   {\r
 382             /* First of all, store the location of the configuration data. */\r
 383             AdcConfigPtr = ConfigPtr;\r
 384 \r
 385             /* Enable ADC. */\r
 386              Adc_ConfigureADC(ConfigPtr);\r
 387 \r
 388              Adc_ConfigureADCInterrupts();\r
 389 \r
 390             /* Move on to INIT state. */\r
 391             adcState = ADC_INIT;\r
 392             return E_OK;\r
 393   }\r
 394   else\r
 395   {\r
 396     return E_NOT_OK;\r
 397   }\r
 398 \r
 399 #else\r
 400 \r
 401   Std_ReturnType returnValue;\r
 402   Adc_InternalChannelIdType channel;\r
 403   Adc_InternalChannelIdType channelId;\r
 404   Adc_GroupType group;\r
 405   Adc_CommandType *commandQueue;\r
 406   Adc_CommandType command;\r
 407 \r
 408   if (E_OK == Adc_CheckInit(ConfigPtr))\r
 409   {\r
 410     /* First of all, store the location of the configuration data. */\r
 411     AdcConfigPtr = ConfigPtr;\r
 412 \r
 413     /* Start configuring the eQADC queues. */\r
 414     for (group = ADC_GROUP0; group < ConfigPtr->nbrOfGroups; group++)\r
 415     {\r
 416       /* Loop through all channels and make the command queue. */\r
 417       for (channel = 0; channel < ConfigPtr->groupConfigPtr[group].numberOfChannels; channel++)\r
 418       {\r
 419         /* Get physical channel. */\r
 420         channelId = ConfigPtr->groupConfigPtr[group].channelList[channel];\r
 421 \r
 422         commandQueue = ConfigPtr->groupConfigPtr[group].commandBuffer;\r
 423 \r
 424         /* Begin with empty command. */\r
 425         command.R = 0;\r
 426 \r
 427         /* Physical channel number. */\r
 428         command.B.CHANNEL_NUMBER = channelId;\r
 429         /* Sample time. */\r
 430         command.B.LST = ConfigPtr->channelConfigPtr [channel].adcChannelConvTime;\r
 431         /* Calibration feature. */\r
 432         command.B.CAL = ConfigPtr->channelConfigPtr [channel].adcChannelCalibrationEnable;\r
 433         /* Result buffer FIFO. The number of groups must not be greater than the number of queues. */\r
 434         command.B.MESSAGE_TAG = group;\r
 435 \r
 436         /* Write command to command queue. */\r
 437         commandQueue [channel].R = command.R;\r
 438 \r
 439         /* Last channel in group. Write EOQ and configure eQADC FIFO. */\r
 440         if (channel == (ConfigPtr->groupConfigPtr[group].numberOfChannels - 1))\r
 441         {\r
 442           commandQueue [channel].B.EOQ = 1;\r
 443         }\r
 444       }\r
 445     }\r
 446 \r
 447     /* Enable ADC. */\r
 448     Adc_ConfigureEQADC (ConfigPtr);\r
 449 \r
 450     /* Perform calibration of the ADC. */\r
 451     Adc_EQADCCalibrationSequence ();\r
 452 \r
 453     /* Configure DMA channels. */\r
 454     for (group = ADC_GROUP0; group < ConfigPtr->nbrOfGroups; group++)\r
 455     {\r
 456       /* ADC307. */\r
 457       ConfigPtr->groupConfigPtr[group].status->groupStatus = ADC_IDLE;\r
 458 \r
 459       Dma_ConfigureChannel ((Dma_TcdType *)ConfigPtr->groupConfigPtr [group].groupDMAResults, ConfigPtr->groupConfigPtr [group].dmaResultChannel);\r
 460       Dma_ConfigureChannel ((Dma_TcdType *)ConfigPtr->groupConfigPtr [group].groupDMACommands, ConfigPtr->groupConfigPtr [group].dmaCommandChannel);\r
 461     }\r
 462 \r
 463     /* Start DMA channels. */\r
 464     for (group = ADC_GROUP0; group < ConfigPtr->nbrOfGroups; group++)\r
 465     {\r
 466       /* Invalidate queues. */\r
 467       EQADC.CFCR[group].B.CFINV = 1;\r
 468 \r
 469       Dma_StartChannel (ConfigPtr->groupConfigPtr [group].dmaResultChannel);\r
 470       Dma_StartChannel (ConfigPtr->groupConfigPtr [group].dmaCommandChannel);\r
 471     }\r
 472 \r
 473     Adc_ConfigureEQADCInterrupts ();\r
 474 \r
 475     /* Move on to INIT state. */\r
 476     adcState = ADC_INIT;\r
 477     returnValue = E_OK;\r
 478   }\r
 479   else\r
 480   {\r
 481     returnValue = E_NOT_OK;\r
 482   }\r
 483 \r
 484   return (returnValue);  \r
 485 #endif  \r
 486 }\r
 487 \r
 488 Std_ReturnType Adc_SetupResultBuffer (Adc_GroupType group, Adc_ValueGroupType *bufferPtr)\r
 489 {\r
 490   Std_ReturnType returnValue = E_NOT_OK;\r
 491 \r
 492   /* Check for development errors. */\r
 493   if (E_OK == Adc_CheckSetupResultBuffer (group))\r
 494   {\r
 495     AdcConfigPtr->groupConfigPtr[group].status->resultBufferPtr = bufferPtr;\r
 496     \r
 497     returnValue = E_OK;\r
 498   }\r
 499 \r
 500   return (returnValue);\r
 501 }\r
 502 \r
 503 Adc_StreamNumSampleType Adc_GetStreamLastPointer(Adc_GroupType group, Adc_ValueGroupType** PtrToSamplePtr)\r
 504 {\r
 505         Adc_StreamNumSampleType nofSample = 0;\r
 506         Adc_GroupDefType *groupPtr = (Adc_GroupDefType *)&AdcConfigPtr->groupConfigPtr[group];\r
 507         \r
 508         /** @req ADC216 */\r
 509         /* Check for development errors. */\r
 510         if ( (E_OK == Adc_CheckGetStreamLastPointer (group)) &&\r
 511                  (groupPtr->status->groupStatus != ADC_BUSY) )\r
 512         {\r
 513             /* Set resultPtr to application buffer. */\r
 514                 if(groupPtr->status->currSampleCount > 0){\r
 515                         *PtrToSamplePtr = &groupPtr->status->resultBufferPtr[groupPtr->status->currSampleCount-1];\r
 516                 }\r
 517 \r
 518             if ((ADC_CONV_MODE_ONESHOT == groupPtr->conversionMode) &&\r
 519                 (ADC_STREAM_COMPLETED  == groupPtr->status->groupStatus))\r
 520             {\r
 521                         /** @req ADC327. */\r
 522                         groupPtr->status->groupStatus = ADC_IDLE;\r
 523             }\r
 524             else if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 525                      (ADC_ACCESS_MODE_STREAMING == groupPtr->accessMode) &&\r
 526                      (ADC_STREAM_BUFFER_LINEAR == groupPtr->streamBufferMode) &&\r
 527                      (ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus))\r
 528             {\r
 529                         /** @req ADC327. */\r
 530                         groupPtr->status->groupStatus = ADC_IDLE;\r
 531             }\r
 532             else if ( (ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 533                       ((ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus) ||\r
 534                        (ADC_COMPLETED           == groupPtr->status->groupStatus)) )\r
 535             {\r
 536                 /* Restart continous mode, and reset result buffer */\r
 537                 if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 538                     (ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus))\r
 539                 {\r
 540                           /* Start continous conversion again */\r
 541                         Adc_StartGroupConversion(group);\r
 542                 }\r
 543                         /** @req ADC326 */\r
 544                         /** @req ADC328 */\r
 545             }\r
 546             else{/* Keep status. */}\r
 547         }\r
 548         else\r
 549         {\r
 550                 /* Some condition not met */\r
 551                 *PtrToSamplePtr = NULL;\r
 552         }\r
 553 \r
 554         return nofSample;\r
 555 \r
 556 }\r
 557 \r
 558 #if (ADC_READ_GROUP_API == STD_ON)\r
 559 Std_ReturnType Adc_ReadGroup (Adc_GroupType group, Adc_ValueGroupType *dataBufferPtr)\r
 560 {\r
 561   Std_ReturnType returnValue = E_OK;\r
 562   uint8_t channel;\r
 563   Adc_GroupDefType *groupPtr = (Adc_GroupDefType *)&AdcConfigPtr->groupConfigPtr[group];\r
 564 \r
 565   if (E_OK == Adc_CheckReadGroup (group))\r
 566   {\r
 567     /* Copy the result to application buffer. */\r
 568     for (channel = 0; channel < groupPtr->numberOfChannels; channel++)\r
 569         {\r
 570                 if(groupPtr->status->currSampleCount > 0){\r
 571                         dataBufferPtr[channel] = (&(groupPtr->status->resultBufferPtr[groupPtr->status->currSampleCount-1]))[channel];\r
 572                 }else{\r
 573                         dataBufferPtr[channel] = groupPtr->status->resultBufferPtr[channel];\r
 574                 }\r
 575         }\r
 576 \r
 577     if ((ADC_CONV_MODE_ONESHOT == groupPtr->conversionMode) &&\r
 578         (ADC_STREAM_COMPLETED  == groupPtr->status->groupStatus))\r
 579     {\r
 580                 /** @req ADC330. */\r
 581                 groupPtr->status->groupStatus = ADC_IDLE;\r
 582     }\r
 583     else if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 584              (ADC_STREAM_BUFFER_LINEAR == groupPtr->streamBufferMode) &&\r
 585              (ADC_ACCESS_MODE_STREAMING == groupPtr->accessMode) &&\r
 586              (ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus))\r
 587     {\r
 588                 /** @req ADC330. */\r
 589                 groupPtr->status->groupStatus = ADC_IDLE;\r
 590     }\r
 591     else if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 592              ((ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus) ||\r
 593               (ADC_COMPLETED           == groupPtr->status->groupStatus)))\r
 594     {\r
 595         /** @req ADC329 */\r
 596       /* Restart continous mode, and reset result buffer */\r
 597       if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 598           (ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus))\r
 599       {\r
 600                   /* Start continous conversion again */\r
 601         Adc_StartGroupConversion(group);\r
 602       }\r
 603       /** @req ADC329 */\r
 604       /** @req ADC331 */\r
 605     }\r
 606     else{/* Keep status. */}\r
 607   }\r
 608   else\r
 609   {\r
 610     /* An error have been raised from Adc_CheckReadGroup(). */\r
 611     returnValue = E_NOT_OK;\r
 612   }\r
 613 \r
 614   return (returnValue);\r
 615 }\r
 616 #endif\r
 617 \r
 618 Adc_StatusType Adc_GetGroupStatus (Adc_GroupType group)\r
 619 {\r
 620         Adc_StatusType returnValue;\r
 621 \r
 622 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
 623         if( (ValidateInit(ADC_GETGROUPSTATUS_ID) == E_NOT_OK) ||\r
 624                 (ValidateGroup(group, ADC_GETGROUPSTATUS_ID) == E_NOT_OK))\r
 625         {\r
 626                 returnValue = ADC_IDLE;\r
 627         }\r
 628         else\r
 629         {\r
 630                 returnValue = AdcConfigPtr->groupConfigPtr[group].status->groupStatus;\r
 631         }\r
 632 #else\r
 633   returnValue = AdcConfigPtr->groupConfigPtr[group].status->groupStatus;\r
 634 #endif\r
 635   return (returnValue);\r
 636 }\r
 637 \r
 638 void Adc_GroupConversionComplete (Adc_GroupType group)\r
 639 {\r
 640         Adc_GroupDefType *adcGroup = (Adc_GroupDefType *)&AdcConfigPtr->groupConfigPtr[group];\r
 641 \r
 642   if(ADC_ACCESS_MODE_SINGLE == adcGroup->accessMode )\r
 643   {\r
 644           adcGroup->status->groupStatus = ADC_STREAM_COMPLETED;\r
 645           /* Call notification if enabled. */\r
 646         #if (ADC_GRP_NOTIF_CAPABILITY == STD_ON)\r
 647           if (adcGroup->status->notifictionEnable && adcGroup->groupCallback != NULL)\r
 648           {\r
 649                   adcGroup->groupCallback();\r
 650           }\r
 651         #endif\r
 652 #if defined(CFG_MPC560X)\r
 653                   /* Disable trigger normal conversions for ADC0 */\r
 654                   ADC_0.MCR.B.NSTART=0;\r
 655 #else\r
 656                   /* Disable trigger. */\r
 657                   EQADC.CFCR[group].B.MODE = 0;\r
 658 #endif\r
 659   }\r
 660   else\r
 661   {\r
 662         if(ADC_STREAM_BUFFER_LINEAR == adcGroup->streamBufferMode)\r
 663         {\r
 664                 adcGroup->status->currSampleCount++;\r
 665                 if(adcGroup->status->currSampleCount < adcGroup->streamNumSamples)\r
 666                 {\r
 667                   adcGroup->status->currResultBufPtr += adcGroup->numberOfChannels;\r
 668                   adcGroup->status->groupStatus = ADC_COMPLETED;\r
 669 \r
 670 #if defined (ADC_USES_DMA)\r
 671                   /* Increase current result buffer ptr */\r
 672                 Dma_ConfigureDestinationAddress((uint32_t)adcGroup->status->currResultBufPtr, adcGroup->dmaResultChannel);\r
 673 #endif\r
 674 \r
 675 #if defined(CFG_MPC560X)\r
 676                 ADC_0.IMR.B.MSKECH = 1;\r
 677             ADC_0.MCR.B.NSTART=1;\r
 678 #else\r
 679                 /* Set single scan enable bit */\r
 680                 EQADC.CFCR[group].B.SSE = 1;\r
 681 #endif\r
 682                 }\r
 683                 else\r
 684                 {\r
 685                   /* All sample completed. */\r
 686                   adcGroup->status->groupStatus = ADC_STREAM_COMPLETED;\r
 687 \r
 688                   /* Call notification if enabled. */\r
 689                 #if (ADC_GRP_NOTIF_CAPABILITY == STD_ON)\r
 690                   if (adcGroup->status->notifictionEnable && adcGroup->groupCallback != NULL){\r
 691                         adcGroup->groupCallback();\r
 692                   }\r
 693                 #endif\r
 694 #if defined(CFG_MPC560X)\r
 695                   /* Disable trigger normal conversions for ADC0 */\r
 696                   ADC_0.MCR.B.NSTART=0;\r
 697 #else\r
 698                   /* Disable trigger. */\r
 699                   EQADC.CFCR[group].B.MODE = 0;\r
 700 #endif\r
 701                 }\r
 702         }\r
 703         else if(ADC_STREAM_BUFFER_CIRCULAR == adcGroup->streamBufferMode)\r
 704         {\r
 705                 adcGroup->status->currSampleCount++;\r
 706                 if(adcGroup->status->currSampleCount < adcGroup->streamNumSamples)\r
 707                 {\r
 708                         adcGroup->status->currResultBufPtr += adcGroup->numberOfChannels;\r
 709 #if defined (ADC_USES_DMA)\r
 710                         /* Increase current result buffer ptr */\r
 711                         Dma_ConfigureDestinationAddress((uint32_t)adcGroup->status->currResultBufPtr, adcGroup->dmaResultChannel);\r
 712 #endif\r
 713                         adcGroup->status->groupStatus = ADC_COMPLETED;\r
 714 \r
 715 #if defined(CFG_MPC560X)\r
 716                         ADC_0.IMR.B.MSKECH = 1;\r
 717                     ADC_0.MCR.B.NSTART=1;\r
 718 #else\r
 719                         /* Set single scan enable bit */\r
 720                         EQADC.CFCR[group].B.SSE = 1;\r
 721 #endif\r
 722                 }\r
 723                 else\r
 724                 {\r
 725                   /* Sample completed. */\r
 726 #if defined(CFG_MPC560X)\r
 727                   /* Disable trigger normal conversions for ADC*/\r
 728                   ADC_0.MCR.B.NSTART=0;\r
 729 #else\r
 730                   /* Disable trigger. */\r
 731                   EQADC.CFCR[group].B.MODE = 0;\r
 732 #endif\r
 733                   adcGroup->status->groupStatus = ADC_STREAM_COMPLETED;\r
 734                   /* Call notification if enabled. */\r
 735                 #if (ADC_GRP_NOTIF_CAPABILITY == STD_ON)\r
 736                   if (adcGroup->status->notifictionEnable && adcGroup->groupCallback != NULL)\r
 737                   {\r
 738                           adcGroup->groupCallback();\r
 739                   }\r
 740                 #endif\r
 741                 }\r
 742         }\r
 743         else\r
 744         {\r
 745                 //nothing to do.\r
 746         }\r
 747   }\r
 748 }\r
 749 #if defined(CFG_MPC560X)\r
 750 void Adc_Group0ConversionComplete (void)\r
 751 {\r
 752         /* Clear ECH Flag and disable interruput */\r
 753         ADC_0.ISR.B.ECH = 1;\r
 754         ADC_0.IMR.B.MSKECH = 0;\r
 755 \r
 756         // Check which group is busy, only one is allowed to be busy at a time in a hw unit\r
 757         for (int group = 0; group < ADC_NBR_OF_GROUPS; group++)\r
 758         {\r
 759           if((AdcConfigPtr->groupConfigPtr[group].status->groupStatus == ADC_BUSY) ||\r
 760        (AdcConfigPtr->groupConfigPtr[group].status->groupStatus == ADC_COMPLETED))\r
 761           {\r
 762 #if !defined (ADC_USES_DMA)\r
 763                 /* Copy to result buffer */\r
 764                 for(uint8 index=0; index < AdcConfigPtr->groupConfigPtr[group].numberOfChannels; index++)\r
 765                 {\r
 766 #if defined(CFG_MPC5606S)\r
 767                         AdcConfigPtr->groupConfigPtr[group].status->currResultBufPtr[index] = ADC_0.CDR[32+AdcConfigPtr->groupConfigPtr[group].channelList[index]].B.CDATA;\r
 768 #else\r
 769                         AdcConfigPtr->groupConfigPtr[group].status->currResultBufPtr[index] = ADC_0.CDR[AdcConfigPtr->groupConfigPtr[group].channelList[index]].B.CDATA;\r
 770 #endif\r
 771                 }\r
 772 #endif\r
 773 \r
 774             Adc_GroupConversionComplete((Adc_GroupType)group);\r
 775                 break;\r
 776           }\r
 777         }\r
 778 }\r
 779 \r
 780 void Adc_WatchdogError (void){\r
 781 }\r
 782 void Adc_ADCError (void){\r
 783 }\r
 784 \r
 785 static void  Adc_ConfigureADC (const Adc_ConfigType *ConfigPtr)\r
 786 {\r
 787   /* Set ADC CLOCK */\r
 788   ADC_0.MCR.B.ADCLKSEL = ConfigPtr->hwConfigPtr->adcPrescale;\r
 789 \r
 790   ADC_0.DSDR.B.DSD = 254;\r
 791 \r
 792   /* Power on ADC */\r
 793   ADC_0.MCR.B.PWDN = 0;\r
 794 \r
 795 #if defined(ADC_USES_DMA)\r
 796   /* Enable DMA. */\r
 797   ADC_0.DMAE.B.DMAEN = 1;\r
 798 #endif\r
 799 }\r
 800 \r
 801 void Adc_ConfigureADCInterrupts (void)\r
 802 {\r
 803         ISR_INSTALL_ISR2(  "Adc_Err", Adc_ADCError, ADC_ER_INT,     2, 0 );\r
 804         ISR_INSTALL_ISR2(  "Adc_Grp", Adc_Group0ConversionComplete, ADC_EOC_INT,     2, 0 );\r
 805         ISR_INSTALL_ISR2(  "Adc_Wdg", Adc_WatchdogError, ADC_WD_INT,     2, 0 );\r
 806 }\r
 807 \r
 808 #if (ADC_ENABLE_START_STOP_GROUP_API == STD_ON)\r
 809 void Adc_StartGroupConversion (Adc_GroupType group)\r
 810 {\r
 811         Adc_GroupDefType *groupPtr = (Adc_GroupDefType *)&AdcConfigPtr->groupConfigPtr[group];\r
 812 \r
 813         /* Run development error check. */\r
 814         if (E_OK == Adc_CheckStartGroupConversion (group))\r
 815         {\r
 816                 /* Disable trigger normal conversions for ADC0 */\r
 817                 ADC_0.MCR.B.NSTART = 0;\r
 818 \r
 819                 /* Set group state to BUSY. */\r
 820                 groupPtr->status->groupStatus = ADC_BUSY;\r
 821 \r
 822                 groupPtr->status->currSampleCount = 0;\r
 823                 groupPtr->status->currResultBufPtr = groupPtr->status->resultBufferPtr; /* Set current result buffer */\r
 824 \r
 825 #if defined(ADC_USES_DMA)\r
 826                 Dma_ConfigureChannel ((Dma_TcdType *)groupPtr->groupDMAResults, groupPtr->dmaResultChannel);\r
 827                 Dma_ConfigureDestinationAddress ((uint32_t)groupPtr->status->currResultBufPtr, groupPtr->dmaResultChannel);\r
 828 #endif\r
 829                 /* Always use single shot in streaming mode */\r
 830                 if( groupPtr->accessMode == ADC_ACCESS_MODE_STREAMING)\r
 831                 {\r
 832                         /* Set conversion mode. */\r
 833                         ADC_0.MCR.B.MODE = ADC_CONV_MODE_ONESHOT;\r
 834                 }\r
 835                 else\r
 836                 {\r
 837                         /* Set conversion mode. */\r
 838                         ADC_0.MCR.B.MODE = groupPtr->conversionMode;\r
 839                 }\r
 840 \r
 841                 /* Enable Overwrite*/\r
 842                 ADC_0.MCR.B.OWREN = 1;\r
 843 \r
 844                 /* Set Conversion Time. */\r
 845 #if defined(CFG_MPC5606S)\r
 846                 uint32 groupChannelIdMask = 0;\r
 847 \r
 848                 ADC_0.CTR[1].B.INPLATCH = groupPtr->adcChannelConvTime.INPLATCH;\r
 849                 ADC_0.CTR[1].B.INPCMP = groupPtr->adcChannelConvTime.INPCMP;\r
 850                 ADC_0.CTR[1].B.INPSAMP = groupPtr->adcChannelConvTime.INPSAMP;\r
 851 \r
 852                 for(uint8 i =0; i < groupPtr->numberOfChannels; i++)\r
 853                 {\r
 854                         groupChannelIdMask |= (1 << groupPtr->channelList[i]);\r
 855                 }\r
 856 \r
 857 #if defined(ADC_USES_DMA)\r
 858                 ADC_0.DMAE.R = 0x01;\r
 859                 /* Enable DMA Transfer */\r
 860                 ADC_0.DMAR[1].R = groupChannelIdMask;\r
 861                 Dma_StartChannel(DMA_ADC_GROUP0_RESULT_CHANNEL);        /* Enable EDMA channel for ADC */\r
 862 #endif\r
 863 \r
 864                 /* Enable Normal conversion */\r
 865                 ADC_0.NCMR[1].R = groupChannelIdMask;\r
 866 \r
 867                 /* Enable Channel Interrupt */\r
 868                 ADC_0.CIMR[1].R = groupChannelIdMask;\r
 869 \r
 870 #else\r
 871                 uint32 groupChannelIdMask[3] = {0,0,0};\r
 872 \r
 873                 ADC_0.CTR[0].B.INPLATCH = groupPtr->adcChannelConvTime.INPLATCH;\r
 874                 ADC_0.CTR[0].B.INPCMP = groupPtr->adcChannelConvTime.INPCMP;\r
 875                 ADC_0.CTR[0].B.INPSAMP = groupPtr->adcChannelConvTime.INPSAMP;\r
 876                 ADC_0.CTR[1].B.INPLATCH = groupPtr->adcChannelConvTime.INPLATCH;\r
 877                 ADC_0.CTR[1].B.INPCMP = groupPtr->adcChannelConvTime.INPCMP;\r
 878                 ADC_0.CTR[1].B.INPSAMP = groupPtr->adcChannelConvTime.INPSAMP;\r
 879                 ADC_0.CTR[2].B.INPLATCH = groupPtr->adcChannelConvTime.INPLATCH;\r
 880                 ADC_0.CTR[2].B.INPCMP = groupPtr->adcChannelConvTime.INPCMP;\r
 881                 ADC_0.CTR[2].B.INPSAMP = groupPtr->adcChannelConvTime.INPSAMP;\r
 882 \r
 883                 for(uint8 i =0; i < groupPtr->numberOfChannels; i++)\r
 884                 {\r
 885                         if(groupPtr->channelList[i] <= 15){\r
 886                                 groupChannelIdMask[0] |= (1 << groupPtr->channelList[i]);\r
 887                         }else if((groupPtr->channelList[i] >= 32) && (groupPtr->channelList[i] <=47)){\r
 888                                 groupChannelIdMask[1] |= (1 << (groupPtr->channelList[i] - 32));\r
 889                         }else if((groupPtr->channelList[i] >= 64) && (groupPtr->channelList[i] <=95)){\r
 890                                 groupChannelIdMask[2] |= (1 << (groupPtr->channelList[i] - 64));\r
 891                         }\r
 892                 }\r
 893 \r
 894                 /* Enable Normal conversion */\r
 895                 ADC_0.NCMR[0].R = groupChannelIdMask[0];\r
 896                 ADC_0.NCMR[1].R = groupChannelIdMask[1];\r
 897                 ADC_0.NCMR[2].R = groupChannelIdMask[2];\r
 898 \r
 899                 /* Enable Channel Interrupt */\r
 900                 ADC_0.CIMR[0].R = groupChannelIdMask[0];\r
 901                 ADC_0.CIMR[1].R = groupChannelIdMask[1];\r
 902                 ADC_0.CIMR[2].R = groupChannelIdMask[2];\r
 903 #endif\r
 904                 /* Clear interrupts */\r
 905                 ADC_0.ISR.B.ECH = 1;\r
 906                 /* Enable ECH interrupt */\r
 907                 ADC_0.IMR.B.MSKECH = 1;\r
 908 \r
 909                 /* Trigger normal conversions for ADC0 */\r
 910                 ADC_0.MCR.B.NSTART = 1;\r
 911         }\r
 912         else\r
 913         {\r
 914         /* Error have been set within Adc_CheckStartGroupConversion(). */\r
 915         }\r
 916 }\r
 917 \r
 918 void Adc_StopGroupConversion (Adc_GroupType group)\r
 919 {\r
 920   if (E_OK == Adc_CheckStopGroupConversion (group))\r
 921   {\r
 922         /* Disable trigger normal conversions for ADC0 */\r
 923         ADC_0.MCR.B.NSTART = 0;\r
 924 \r
 925         /* Set group state to IDLE. */\r
 926         AdcConfigPtr->groupConfigPtr[group].status->groupStatus = ADC_IDLE;\r
 927 \r
 928         /* Disable group notification if enabled. */\r
 929     if(1 == AdcConfigPtr->groupConfigPtr[group].status->notifictionEnable){\r
 930         Adc_DisableGroupNotification (group);\r
 931     }\r
 932   }\r
 933   else\r
 934   {\r
 935         /* Error have been set within Adc_CheckStartGroupConversion(). */\r
 936   }\r
 937 }\r
 938 #endif  /* endof #if (ADC_ENABLE_START_STOP_GROUP_API == STD_ON) */\r
 939 \r
 940 #else /* End of mpc5606s unique */\r
 941 \r
 942 void Adc_Group0ConversionComplete (void)\r
 943 {\r
 944   /* ISR for FIFO 0 end of queue. Clear interrupt flag.  */\r
 945   EQADC.FISR[ADC_EQADC_QUEUE_0].B.EOQF = 1;\r
 946   Adc_GroupConversionComplete(0);\r
 947 }\r
 948 void Adc_Group1ConversionComplete (void)\r
 949 {\r
 950   /* ISR for FIFO 0 end of queue. Clear interrupt flag.  */\r
 951   EQADC.FISR[ADC_EQADC_QUEUE_1].B.EOQF = 1;\r
 952   Adc_GroupConversionComplete(1);\r
 953 }\r
 954 void Adc_Group2ConversionComplete (void)\r
 955 {\r
 956   /* ISR for FIFO 0 end of queue. Clear interrupt flag.  */\r
 957   EQADC.FISR[ADC_EQADC_QUEUE_2].B.EOQF = 1;\r
 958   Adc_GroupConversionComplete(2);\r
 959 }\r
 960 void Adc_Group3ConversionComplete (void)\r
 961 {\r
 962   /* ISR for FIFO 0 end of queue. Clear interrupt flag.  */\r
 963   EQADC.FISR[ADC_EQADC_QUEUE_3].B.EOQF = 1;\r
 964   Adc_GroupConversionComplete(3);\r
 965 }\r
 966 void Adc_Group4ConversionComplete (void)\r
 967 {\r
 968   /* ISR for FIFO 0 end of queue. Clear interrupt flag.  */\r
 969   EQADC.FISR[ADC_EQADC_QUEUE_4].B.EOQF = 1;\r
 970   Adc_GroupConversionComplete(4);\r
 971 }\r
 972 void Adc_Group5ConversionComplete (void)\r
 973 {\r
 974   /* ISR for FIFO 0 end of queue. Clear interrupt flag.  */\r
 975   EQADC.FISR[ADC_EQADC_QUEUE_5].B.EOQF = 1;\r
 976   Adc_GroupConversionComplete(5);\r
 977 }\r
 978 \r
 979 void Adc_EQADCError (void)\r
 980 {\r
 981   /* Something is wrong!! Check the cause of the error and try to correct it. */\r
 982   if (EQADC.FISR[ADC_EQADC_QUEUE_0].B.TORF)\r
 983   {\r
 984     /* Trigger overrun on queue 0!! */\r
 985     assert (0);\r
 986   }\r
 987   else if (EQADC.FISR[ADC_EQADC_QUEUE_1].B.TORF)\r
 988   {\r
 989     /* Trigger overrun on queue 1!! */\r
 990     assert (0);\r
 991   }\r
 992   else if (EQADC.FISR[ADC_EQADC_QUEUE_0].B.CFUF)\r
 993   {\r
 994     /* Command underflow on queue 0!! */\r
 995     assert (0);\r
 996   }\r
 997   else if (EQADC.FISR[ADC_EQADC_QUEUE_1].B.CFUF)\r
 998   {\r
 999     /* Command underflow on queue 1!! */\r
1000     assert (0);\r
1001   }\r
1002   else if (EQADC.FISR[ADC_EQADC_QUEUE_0].B.RFOF)\r
1003   {\r
1004     /* Result overflow on queue 0!! */\r
1005     assert (0);\r
1006   }\r
1007   else if (EQADC.FISR[ADC_EQADC_QUEUE_1].B.RFOF)\r
1008   {\r
1009     /* Result overflow on queue 1!! */\r
1010     assert (0);\r
1011   }\r
1012   else\r
1013   {\r
1014     /* Something else... TODO What have we missed above */\r
1015     assert(0);\r
1016   }\r
1017 }\r
1018 \r
1019 /* Helper macro to make sure that the qommand queue have\r
1020  * executed the commands in the fifo.\r
1021  * First check that the H/W negate the\r
1022  * single scan bit and then wait for EOQ. */\r
1023 #define WAIT_FOR_QUEUE_TO_FINISH(q) \\r
1024   while (EQADC.FISR[q].B.SSS)             \\r
1025   {                                       \\r
1026     ;                                     \\r
1027   }                                       \\r
1028                                           \\r
1029   while (!EQADC.FISR[q].B.EOQF)           \\r
1030   {                                       \\r
1031     ;                                     \\r
1032   }\r
1033 \r
1034 static void Adc_WriteEQADCRegister (Adc_EQADCRegisterType reg, Adc_EQADCRegister value)\r
1035 {\r
1036   Adc_RegisterWriteType writeReg;\r
1037   uint32_t temp, oldMode;\r
1038 \r
1039   writeReg.R = 0;\r
1040 \r
1041   /* Write command. */\r
1042   writeReg.B.RW = 0;\r
1043   writeReg.B.EOQ = 1;\r
1044   writeReg.B.ADC_REG = value;\r
1045   writeReg.B.ADC_REG_ADDR = reg;\r
1046 \r
1047   /* Invalidate queue. */\r
1048   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.CFINV = 1;\r
1049 \r
1050 \r
1051   /* Write command through FIFO. */\r
1052   EQADC.CFPR[ADC_EQADC_QUEUE_0].R = writeReg.R;\r
1053 \r
1054   /* Enable FIFO. */\r
1055   oldMode = EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE;\r
1056   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE = ADC_CONV_MODE_ONESHOT;\r
1057   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.SSE = 1;\r
1058 \r
1059   /* Wait for command to be executed. */\r
1060   WAIT_FOR_QUEUE_TO_FINISH(ADC_EQADC_QUEUE_0);\r
1061 \r
1062   /* Flush result buffer. */\r
1063   temp = EQADC.RFPR[ADC_EQADC_QUEUE_0].R;\r
1064   EQADC.FISR[ADC_EQADC_QUEUE_0].B.EOQF = 1;\r
1065 \r
1066   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE = oldMode;\r
1067 \r
1068 }\r
1069 \r
1070 static Adc_EQADCRegister Adc_ReadEQADCRegister (Adc_EQADCRegisterType reg)\r
1071 {\r
1072   Adc_RegisterReadType readReg;\r
1073   Adc_EQADCRegister result;\r
1074   uint32_t oldMode, dmaRequestEnable;\r
1075 \r
1076   readReg.R = 0;\r
1077 \r
1078   /* Read command. */\r
1079   readReg.B.RW = 1;\r
1080   readReg.B.EOQ = 1;\r
1081   readReg.B.ADC_REG_ADDR = reg;\r
1082   readReg.B.MESSAGE_TAG = ADC_EQADC_QUEUE_0;\r
1083 \r
1084   /* Make sure that DMA requests for command fill and result drain is disabled. */\r
1085   if (EQADC.IDCR[ADC_EQADC_QUEUE_0].B.RFDE || EQADC.IDCR[ADC_EQADC_QUEUE_0].B.CFFE)\r
1086   {\r
1087     EQADC.IDCR[ADC_EQADC_QUEUE_0].B.CFFE = 0;\r
1088     EQADC.IDCR[ADC_EQADC_QUEUE_0].B.RFDE = 0;\r
1089 \r
1090     /* Remember to enable requests again... */\r
1091     dmaRequestEnable = TRUE;\r
1092   }\r
1093   else\r
1094   {\r
1095     dmaRequestEnable = FALSE;\r
1096   }\r
1097 \r
1098   /* Invalidate queue. */\r
1099   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.CFINV = 1;\r
1100 \r
1101   /* Write command through FIFO. */\r
1102   EQADC.CFPR[ADC_EQADC_QUEUE_0].R = readReg.R;\r
1103 \r
1104   /* Enable FIFO. */\r
1105   oldMode = EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE;\r
1106   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE = ADC_CONV_MODE_ONESHOT;\r
1107   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.SSE = 1;\r
1108 \r
1109   /* Wait for command to be executed. */\r
1110   WAIT_FOR_QUEUE_TO_FINISH(ADC_EQADC_QUEUE_0);\r
1111 \r
1112   /* Read result buffer. */\r
1113   result = EQADC.RFPR[ADC_EQADC_QUEUE_0].R;\r
1114   EQADC.FISR[ADC_EQADC_QUEUE_0].B.EOQF = 1;\r
1115 \r
1116   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE = oldMode;\r
1117 \r
1118   if (dmaRequestEnable)\r
1119   {\r
1120     EQADC.IDCR[ADC_EQADC_QUEUE_0].B.CFFE = 1;\r
1121     EQADC.IDCR[ADC_EQADC_QUEUE_0].B.RFDE = 1;\r
1122   }\r
1123   else\r
1124   {\r
1125     /* Do nothing. */\r
1126   }\r
1127   return (result);\r
1128 }\r
1129 static void  Adc_ConfigureEQADC (const Adc_ConfigType *ConfigPtr)\r
1130 {\r
1131   Adc_GroupType group;\r
1132 \r
1133   enum\r
1134   {\r
1135     ADC_ENABLE = 0x8000,\r
1136   };\r
1137   /* Enable ADC0. */\r
1138   Adc_WriteEQADCRegister (ADC0_CR, (ADC_ENABLE | ConfigPtr->hwConfigPtr->adcPrescale));\r
1139 \r
1140   /* Disable time stamp timer. */\r
1141   Adc_WriteEQADCRegister (ADC0_TSCR, 0);\r
1142 \r
1143   for (group = ADC_GROUP0; group < ConfigPtr->nbrOfGroups; group++)\r
1144   {\r
1145     /* Enable eDMA requests for commands and results. */\r
1146     EQADC.IDCR[group].B.CFFS = 1;\r
1147     EQADC.IDCR[group].B.RFDS = 1;\r
1148 \r
1149     /* Invalidate FIFO. */\r
1150     EQADC.CFCR[group].B.CFINV = 1;\r
1151 \r
1152     /* Enable FIFO fill requests. */\r
1153     EQADC.IDCR[group].B.CFFE = 1;\r
1154     EQADC.IDCR[group].B.RFDE = 1;\r
1155   }\r
1156 }\r
1157 \r
1158 void Adc_ConfigureEQADCInterrupts (void)\r
1159 {\r
1160   Adc_GroupType group;\r
1161   ISR_INSTALL_ISR2( "Adc_Err", Adc_EQADCError, EQADC_FISR_OVER,     2, 0);\r
1162   for (group = ADC_GROUP0; group < AdcConfigPtr->nbrOfGroups; group++)\r
1163   {\r
1164     /* Enable end of queue, queue overflow/underflow interrupts. Clear corresponding flags. */\r
1165     EQADC.FISR[group].B.RFOF = 1;\r
1166     EQADC.IDCR[group].B.RFOIE = 1;\r
1167 \r
1168     EQADC.FISR[group].B.CFUF = 1;\r
1169     EQADC.IDCR[group].B.CFUIE = 1;\r
1170 \r
1171     EQADC.FISR[group].B.TORF = 1;\r
1172     EQADC.IDCR[group].B.TORIE = 1;\r
1173 \r
1174     EQADC.FISR[group].B.EOQF = 1;\r
1175     EQADC.IDCR[group].B.EOQIE = 1;\r
1176     if(group == 0){\r
1177         ISR_INSTALL_ISR2( "Adc_Grp0", Adc_Group0ConversionComplete, EQADC_FISR0_EOQF0,     2, 0);\r
1178     }else if(group == 1){\r
1179         ISR_INSTALL_ISR2( "Adc_Grp1", Adc_Group1ConversionComplete, EQADC_FISR1_EOQF1,     2, 0);\r
1180         }else if(group == 2){\r
1181                 ISR_INSTALL_ISR2( "Adc_Grp2", Adc_Group2ConversionComplete, EQADC_FISR2_EOQF2,     2, 0);\r
1182         }else if(group == 3){\r
1183                 ISR_INSTALL_ISR2( "Adc_Grp3", Adc_Group3ConversionComplete, EQADC_FISR3_EOQF3,     2, 0);\r
1184         }else if(group == 4){\r
1185                 ISR_INSTALL_ISR2( "Adc_Grp4", Adc_Group4ConversionComplete, EQADC_FISR4_EOQF4,     2, 0);\r
1186         }else if(group == 5){\r
1187                 ISR_INSTALL_ISR2( "Adc_Grp5", Adc_Group5ConversionComplete, EQADC_FISR5_EOQF5,     2, 0);\r
1188         }\r
1189   }\r
1190 }\r
1191 \r
1192 #if (ADC_ENABLE_START_STOP_GROUP_API == STD_ON)\r
1193 void Adc_StartGroupConversion (Adc_GroupType group)\r
1194 {\r
1195         Adc_GroupDefType *groupPtr = (Adc_GroupDefType *)&AdcConfigPtr->groupConfigPtr[group];\r
1196 \r
1197         /* Run development error check. */\r
1198         if (E_OK == Adc_CheckStartGroupConversion (group))\r
1199         {\r
1200         /* Disable trigger. */\r
1201         EQADC.CFCR[group].B.MODE = 0;\r
1202 \r
1203         /* Set group state to BUSY. */\r
1204                 groupPtr->status->groupStatus = ADC_BUSY;\r
1205 \r
1206                 groupPtr->status->currSampleCount = 0;\r
1207                 groupPtr->status->currResultBufPtr = groupPtr->status->resultBufferPtr; /* Set current result buffer */\r
1208 \r
1209                 Dma_ConfigureDestinationAddress((uint32_t)groupPtr->status->resultBufferPtr, groupPtr->dmaResultChannel);\r
1210 \r
1211                 /* Always use single shot in streaming mode */\r
1212                 if( groupPtr->accessMode == ADC_ACCESS_MODE_STREAMING)\r
1213                 {\r
1214                         /* Set conversion mode. */\r
1215                         EQADC.CFCR[group].B.MODE = ADC_CONV_MODE_ONESHOT;\r
1216                         /* Set single scan enable bit if this group is one shot. */\r
1217                         EQADC.CFCR[group].B.SSE = 1;\r
1218                 }\r
1219                 else\r
1220                 {\r
1221                         /* Set conversion mode. */\r
1222                         EQADC.CFCR[group].B.MODE = groupPtr->conversionMode;\r
1223                         /* Set single scan enable bit if this group is one shot. */\r
1224                         if (AdcConfigPtr->groupConfigPtr[group].conversionMode == ADC_CONV_MODE_ONESHOT)\r
1225                         {\r
1226                           EQADC.CFCR[group].B.SSE = 1;\r
1227                         }\r
1228                 }\r
1229         }\r
1230         else\r
1231         {\r
1232         /* Error have been set within Adc_CheckStartGroupConversion(). */\r
1233         }\r
1234 }\r
1235 \r
1236 void Adc_StopGroupConversion (Adc_GroupType group)\r
1237 {\r
1238         if (E_OK == Adc_CheckStopGroupConversion (group))\r
1239         {\r
1240                 uint32 groupMask = 0x3 << (group * 2);\r
1241                 /* Disable trigger normal conversions for ADC */\r
1242                 EQADC.CFCR[group].B.MODE = 0;\r
1243                 while((EQADC.CFSR.R & groupMask) != EQADC_CFIFO_STATUS_IDLE);\r
1244 \r
1245                 /* Invalidate FIFO. */\r
1246                 EQADC.CFCR[group].B.CFINV = 1;\r
1247 \r
1248                 /* Set group state to IDLE. */\r
1249                 AdcConfigPtr->groupConfigPtr[group].status->groupStatus = ADC_IDLE;\r
1250 \r
1251                 /* Disable group notification if enabled. */\r
1252                 if(1 == AdcConfigPtr->groupConfigPtr[group].status->notifictionEnable){\r
1253                         Adc_DisableGroupNotification (group);\r
1254                 }\r
1255         }\r
1256         else\r
1257         {\r
1258         /* Error have been set within Adc_CheckStartGroupConversion(). */\r
1259         }\r
1260 }\r
1261 #endif\r
1262 \r
1263 static void Adc_EQADCCalibrationSequence (void)\r
1264 {\r
1265   Adc_ValueGroupType calibrationResult[sizeof(AdcCalibrationCommandQueue)/sizeof(AdcCalibrationCommandQueue[0])];\r
1266   int32_t point25Average, point75Average, i;\r
1267   Adc_EQADCRegister tempGCC, tempOCC;\r
1268   enum\r
1269   {\r
1270     IDEAL_RES25 = 0x1000,\r
1271     IDEAL_RES75 = 0x3000,\r
1272   };\r
1273 \r
1274   /* Use group 0 DMA channel for calibration. */\r
1275   Dma_ConfigureChannel ((Dma_TcdType *)&AdcCalibrationDMACommandConfig,DMA_ADC_GROUP0_COMMAND_CHANNEL);\r
1276   Dma_ConfigureChannelTranferSize (sizeof(AdcCalibrationCommandQueue)/sizeof(AdcCalibrationCommandQueue[0]),\r
1277                                            DMA_ADC_GROUP0_COMMAND_CHANNEL);\r
1278   Dma_ConfigureChannelSourceCorr (-sizeof(AdcCalibrationCommandQueue), DMA_ADC_GROUP0_COMMAND_CHANNEL);\r
1279 \r
1280   Dma_ConfigureChannel ((Dma_TcdType *)&AdcCalibrationDMAResultConfig, DMA_ADC_GROUP0_RESULT_CHANNEL);\r
1281   Dma_ConfigureChannelTranferSize (sizeof(calibrationResult)/sizeof(calibrationResult[0]),\r
1282                                            DMA_ADC_GROUP0_RESULT_CHANNEL);\r
1283   Dma_ConfigureChannelDestinationCorr (-sizeof(calibrationResult), DMA_ADC_GROUP0_RESULT_CHANNEL);\r
1284   Dma_ConfigureDestinationAddress ((uint32_t)calibrationResult, DMA_ADC_GROUP0_RESULT_CHANNEL);\r
1285 \r
1286   /* Invalidate queues. */\r
1287   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.CFINV = 1;\r
1288 \r
1289   Dma_StartChannel (DMA_ADC_GROUP0_COMMAND_CHANNEL);\r
1290   Dma_StartChannel (DMA_ADC_GROUP0_RESULT_CHANNEL);\r
1291 \r
1292   /* Start conversion. */\r
1293   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE = ADC_CONV_MODE_ONESHOT;\r
1294   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.SSE = 1;\r
1295 \r
1296   /* Wait for conversion to complete. */\r
1297   while(!Dma_ChannelDone (DMA_ADC_GROUP0_RESULT_CHANNEL))\r
1298   {\r
1299     ;\r
1300   }\r
1301 \r
1302   /* Stop DMA channels and write calibration data to ADC engine. */\r
1303   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE = ADC_CONV_MODE_DISABLED;\r
1304   Dma_StopChannel (DMA_ADC_GROUP0_COMMAND_CHANNEL);\r
1305   Dma_StopChannel (DMA_ADC_GROUP0_RESULT_CHANNEL);\r
1306 \r
1307   /* Calculate conversion factors and write to ADC. */\r
1308   point25Average = 0;\r
1309   point75Average = 0;\r
1310   for (i = 0; i < sizeof(calibrationResult)/sizeof(calibrationResult[0] / 2); i++)\r
1311   {\r
1312     point25Average += calibrationResult[i];\r
1313     point75Average += calibrationResult[i + sizeof(calibrationResult)/sizeof(calibrationResult[0]) / 2];\r
1314   }\r
1315 \r
1316   /* Calculate average and correction slope and offset.  */\r
1317   point25Average /= (sizeof(calibrationResult)/sizeof(calibrationResult[0]) / 2);\r
1318   point75Average /= (sizeof(calibrationResult)/sizeof(calibrationResult[0]) / 2);\r
1319 \r
1320   tempGCC = ((IDEAL_RES75 - IDEAL_RES25) << 14) / (point75Average - point25Average);\r
1321   tempOCC = IDEAL_RES75 - ((tempGCC * point75Average) >> 14) - 2;\r
1322 \r
1323   /* GCC field is only 15 bits. */\r
1324   tempGCC = tempGCC & ~(1 << 15);\r
1325 \r
1326   /* OCC field is only 14 bits. */\r
1327   tempOCC = tempOCC & ~(3 << 14);\r
1328 \r
1329   /* Write calibration data to ADC engine. */\r
1330   Adc_WriteEQADCRegister (ADC0_GCCR, tempGCC);\r
1331   Adc_WriteEQADCRegister (ADC0_OCCR, tempOCC);\r
1332 \r
1333   /* Read back and check calibration values. */\r
1334   if (Adc_ReadEQADCRegister (ADC0_GCCR) != tempGCC)\r
1335   {\r
1336     assert (0);\r
1337   }\r
1338   else if (Adc_ReadEQADCRegister (ADC0_OCCR) != tempOCC)\r
1339   {\r
1340     assert (0);\r
1341   }\r
1342 }\r
1343 #endif\r
1344 \r
1345 #define SYSTEM_CLOCK_DIVIDE(f)    ((f / 2) - 1)\r
1346 \r
1347 #if (ADC_GRP_NOTIF_CAPABILITY == STD_ON)\r
1348 void Adc_EnableGroupNotification (Adc_GroupType group)\r
1349 {\r
1350         Std_ReturnType res;\r
1351 \r
1352 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1353         if( (ValidateInit(ADC_ENABLEGROUPNOTIFICATION_ID) == E_NOT_OK) ||\r
1354                 (ValidateGroup(group, ADC_ENABLEGROUPNOTIFICATION_ID) == E_NOT_OK))\r
1355         {\r
1356                 res = E_NOT_OK;\r
1357         }\r
1358         else if (AdcConfigPtr->groupConfigPtr[group].groupCallback == NULL)\r
1359         {\r
1360                 res = E_NOT_OK;\r
1361                 Det_ReportError(MODULE_ID_ADC,0,ADC_ENABLEGROUPNOTIFICATION_ID ,ADC_E_NOTIF_CAPABILITY );\r
1362         }\r
1363         else\r
1364         {\r
1365                 /* Nothing strange. Go on... */\r
1366                 res = E_OK;\r
1367         }\r
1368 #else\r
1369         res = E_OK;\r
1370 #endif\r
1371         if (E_OK == res){\r
1372                 AdcConfigPtr->groupConfigPtr[group].status->notifictionEnable = 1;\r
1373         }\r
1374 }\r
1375 \r
1376 void Adc_DisableGroupNotification (Adc_GroupType group)\r
1377 {\r
1378         Std_ReturnType res;\r
1379 \r
1380 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1381         if( (ValidateInit(ADC_DISABLEGROUPNOTIFICATION_ID) == E_NOT_OK) ||\r
1382                 (ValidateGroup(group, ADC_DISABLEGROUPNOTIFICATION_ID) == E_NOT_OK))\r
1383         {\r
1384                 res = E_NOT_OK;\r
1385         }\r
1386         else if (AdcConfigPtr->groupConfigPtr[group].groupCallback == NULL)\r
1387         {\r
1388                 res = E_NOT_OK;\r
1389                 Det_ReportError(MODULE_ID_ADC,0,ADC_DISABLEGROUPNOTIFICATION_ID ,ADC_E_NOTIF_CAPABILITY );\r
1390         }\r
1391         else\r
1392         {\r
1393                 /* Nothing strange. Go on... */\r
1394                 res = E_OK;\r
1395         }\r
1396 #else\r
1397         res = E_OK;\r
1398 #endif\r
1399         if (E_OK == res){\r
1400                 AdcConfigPtr->groupConfigPtr[group].status->notifictionEnable = 0;\r
1401         }\r
1402 }\r
1403 #endif\r
1404 \r
1405 \r
1406 \r
1407 /* Development error checking functions. */\r
1408 #if (ADC_READ_GROUP_API == STD_ON)\r
1409 static Std_ReturnType Adc_CheckReadGroup (Adc_GroupType group)\r
1410 {\r
1411   Std_ReturnType returnValue = E_OK;\r
1412 \r
1413 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1414 \r
1415   if( (ValidateInit(ADC_READGROUP_ID) == E_NOT_OK) ||\r
1416       (ValidateGroup(group, ADC_READGROUP_ID) == E_NOT_OK))\r
1417   {\r
1418           returnValue = E_NOT_OK;\r
1419   }\r
1420   else if (ADC_IDLE == AdcConfigPtr->groupConfigPtr[group].status->groupStatus)\r
1421   {\r
1422     /* ADC388. */\r
1423     returnValue = E_NOT_OK;\r
1424     Det_ReportError(MODULE_ID_ADC,0,ADC_READGROUP_ID ,ADC_E_IDLE );\r
1425   }\r
1426   else\r
1427   {\r
1428     /* Nothing strange. Go on... */\r
1429     returnValue = E_OK;\r
1430   }\r
1431 #endif\r
1432   return (returnValue);\r
1433 }\r
1434 #endif\r
1435 \r
1436 #if (ADC_ENABLE_START_STOP_GROUP_API == STD_ON)\r
1437 static Std_ReturnType Adc_CheckStartGroupConversion (Adc_GroupType group)\r
1438 {\r
1439   Std_ReturnType returnValue = E_OK;\r
1440 \r
1441 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1442 \r
1443   if( (ValidateInit(ADC_STARTGROUPCONVERSION_ID) == E_NOT_OK) ||\r
1444       (ValidateGroup(group, ADC_STARTGROUPCONVERSION_ID) == E_NOT_OK))\r
1445   {\r
1446           returnValue = E_NOT_OK;\r
1447   }\r
1448   else if ( NULL == AdcConfigPtr->groupConfigPtr[group].status->resultBufferPtr )\r
1449   {\r
1450       /* ResultBuffer not set, ADC424 */\r
1451           Det_ReportError(MODULE_ID_ADC,0,ADC_STARTGROUPCONVERSION_ID, ADC_E_BUFFER_UNINIT );\r
1452           returnValue = E_NOT_OK;\r
1453   }\r
1454   else if (!(ADC_TRIGG_SRC_SW == AdcConfigPtr->groupConfigPtr[group].triggerSrc))\r
1455   {\r
1456     /* Wrong trig source, ADC133. */\r
1457     Det_ReportError(MODULE_ID_ADC,0,ADC_STARTGROUPCONVERSION_ID, ADC_E_WRONG_TRIGG_SRC);\r
1458     returnValue = E_NOT_OK;\r
1459   }\r
1460   else if (!((ADC_IDLE             == AdcConfigPtr->groupConfigPtr[group].status->groupStatus) ||\r
1461              (ADC_STREAM_COMPLETED == AdcConfigPtr->groupConfigPtr[group].status->groupStatus)))\r
1462   {\r
1463     /* Group status not OK, ADC351, ADC428 */\r
1464     Det_ReportError(MODULE_ID_ADC,0,ADC_STARTGROUPCONVERSION_ID, ADC_E_BUSY );\r
1465 \r
1466     //returnValue = E_NOT_OK;\r
1467     returnValue = E_OK;\r
1468   }\r
1469   else\r
1470   {\r
1471     returnValue = E_OK;\r
1472   }\r
1473 #endif\r
1474 \r
1475   return (returnValue);\r
1476 }\r
1477 \r
1478 static Std_ReturnType Adc_CheckStopGroupConversion (Adc_GroupType group)\r
1479 {\r
1480   Std_ReturnType returnValue = E_OK;\r
1481 \r
1482 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1483   if( (ValidateInit(ADC_STOPGROUPCONVERSION_ID) == E_NOT_OK) ||\r
1484       (ValidateGroup(group, ADC_STOPGROUPCONVERSION_ID) == E_NOT_OK))\r
1485   {\r
1486           returnValue = E_NOT_OK;\r
1487   }\r
1488   else if (!(ADC_TRIGG_SRC_SW == AdcConfigPtr->groupConfigPtr[group].triggerSrc))\r
1489   {\r
1490         /* Wrong trig source, ADC164. */\r
1491         Det_ReportError(MODULE_ID_ADC,0,ADC_STOPGROUPCONVERSION_ID, ADC_E_WRONG_TRIGG_SRC);\r
1492         returnValue = E_NOT_OK;\r
1493   }\r
1494   else if (ADC_IDLE == AdcConfigPtr->groupConfigPtr[group].status->groupStatus)\r
1495   {\r
1496         /* Group status not OK, ADC241 */\r
1497         Det_ReportError(MODULE_ID_ADC,0,ADC_STOPGROUPCONVERSION_ID, ADC_E_IDLE );\r
1498         returnValue = E_NOT_OK;\r
1499   }\r
1500   else\r
1501   {\r
1502         returnValue = E_OK;\r
1503   }\r
1504 #endif\r
1505 \r
1506   return (returnValue);\r
1507 }\r
1508 #endif\r
1509 \r
1510 static Std_ReturnType Adc_CheckInit (const Adc_ConfigType *ConfigPtr)\r
1511 {\r
1512   Std_ReturnType returnValue = E_OK;\r
1513 \r
1514 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1515   if (!(ADC_UNINIT == adcState))\r
1516   {\r
1517     /* Oops, already initialised. */\r
1518     Det_ReportError(MODULE_ID_ADC,0,ADC_INIT_ID, ADC_E_ALREADY_INITIALIZED );\r
1519     returnValue = E_NOT_OK;\r
1520   }\r
1521   else if (ConfigPtr == NULL)\r
1522   {\r
1523     /* Wrong config! */\r
1524     Det_ReportError(MODULE_ID_ADC,0,ADC_INIT_ID, ADC_E_PARAM_CONFIG );\r
1525     returnValue = E_NOT_OK;\r
1526   }\r
1527   else\r
1528   {\r
1529     /* Looks good!! */\r
1530     returnValue = E_OK;\r
1531   }\r
1532 #endif\r
1533   return (returnValue);\r
1534 }\r
1535 \r
1536 #if (ADC_DEINIT_API == STD_ON)\r
1537 static Std_ReturnType Adc_CheckDeInit (void)\r
1538 {\r
1539         Std_ReturnType returnValue = E_OK;\r
1540 \r
1541 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1542         if(ValidateInit(ADC_DEINIT_ID) == E_OK)\r
1543         {\r
1544                 for (Adc_GroupType group = ADC_GROUP0; group < AdcConfigPtr->nbrOfGroups; group++)\r
1545                 {\r
1546                         /*  Check ADC is IDLE or COMPLETE*/\r
1547                         if((AdcConfigPtr->groupConfigPtr[group].status->groupStatus != ADC_IDLE) && (AdcConfigPtr->groupConfigPtr[group].status->groupStatus != ADC_STREAM_COMPLETED))\r
1548                         {\r
1549                                 Det_ReportError(MODULE_ID_ADC,0,ADC_DEINIT_ID, ADC_E_BUSY );\r
1550                                 returnValue = E_NOT_OK;\r
1551                         }\r
1552                 }\r
1553         }\r
1554         else\r
1555         {\r
1556                 returnValue = E_NOT_OK;\r
1557         }\r
1558 #endif\r
1559         return (returnValue);\r
1560 }\r
1561 #endif\r
1562 \r
1563 static Std_ReturnType Adc_CheckSetupResultBuffer (Adc_GroupType group)\r
1564 {\r
1565   Std_ReturnType returnValue = E_OK;\r
1566 \r
1567 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1568   if(ValidateGroup(group, ADC_SETUPRESULTBUFFER_ID) == E_NOT_OK)\r
1569   {\r
1570           returnValue = E_NOT_OK;\r
1571   }\r
1572 #endif\r
1573   return (returnValue);\r
1574 }\r
1575 \r
1576 static Std_ReturnType Adc_CheckGetStreamLastPointer (Adc_GroupType group)\r
1577 {\r
1578   Std_ReturnType returnValue = E_OK;\r
1579 \r
1580 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1581   if( (ValidateInit(ADC_GETSTREAMLASTPOINTER_ID) == E_NOT_OK) ||\r
1582           (ValidateGroup(group, ADC_GETSTREAMLASTPOINTER_ID) == E_NOT_OK))\r
1583   {\r
1584           returnValue = E_NOT_OK;\r
1585   }\r
1586   else if(AdcConfigPtr->groupConfigPtr[group].status->groupStatus == ADC_IDLE)\r
1587   { /** @req ADC215 Check ADC is not in IDLE */\r
1588         Det_ReportError(MODULE_ID_ADC,0,ADC_GETSTREAMLASTPOINTER_ID, ADC_E_IDLE );\r
1589         returnValue = E_NOT_OK;\r
1590   }\r
1591 #endif\r
1592   return (returnValue);\r
1593 }\r
1594 \r
1595 \r
1596 \r