arch/ppc/mpc55xx/drivers/eQADC.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 #define ADC_USES_DMA\r
  30 #include "Dma.h"\r
  31 \r
  32 #if ( defined(ADC_USES_DMA) && !defined(USE_DMA) )\r
  33         #error Adc is configured to use Dma but the module is not enabled.\r
  34 #endif\r
  35 \r
  36 #define ADC_GROUP0              0\r
  37 \r
  38 typedef union\r
  39 {\r
  40   vuint32_t R;\r
  41   struct\r
  42   {\r
  43     vuint32_t EOQ:1;\r
  44     vuint32_t PAUSE:1;\r
  45     vuint32_t :4;\r
  46     vuint32_t BN:1;\r
  47     vuint32_t RW:1;\r
  48     vuint32_t ADC_REG:16;\r
  49     vuint32_t ADC_REG_ADDR:8;\r
  50    } B;\r
  51 }Adc_RegisterWriteType;\r
  52 \r
  53 typedef union\r
  54 {\r
  55   vuint32_t R;\r
  56   struct\r
  57   {\r
  58     vuint32_t EOQ:1;\r
  59     vuint32_t PAUSE:1;\r
  60     vuint32_t :4;\r
  61     vuint32_t BN:1;\r
  62     vuint32_t RW:1;\r
  63     vuint32_t MESSAGE_TAG:4;\r
  64     vuint32_t :12;\r
  65     vuint32_t ADC_REG_ADDR:8;\r
  66    } B;\r
  67 }Adc_RegisterReadType;\r
  68 \r
  69 typedef enum\r
  70 {\r
  71   ADC_EQADC_QUEUE_0,\r
  72   ADC_EQADC_QUEUE_1,\r
  73   ADC_EQADC_QUEUE_2,\r
  74   ADC_EQADC_QUEUE_3,\r
  75   ADC_EQADC_QUEUE_4,\r
  76   ADC_EQADC_QUEUE_5,\r
  77   ADC_EQADC_NBR_OF_QUEUES\r
  78 }Adc_eQADCQueueType;\r
  79 \r
  80 typedef enum\r
  81 {\r
  82   EQADC_CFIFO_STATUS_IDLE = 0,\r
  83   EQADC_CFIFO_STATUS_WAITINGFOR_TRIGGER = 0x2,\r
  84   EQADC_CFIFO_STATUS_TRIGGERED = 0x3\r
  85 }Adc_EQADCQueueStatusType;\r
  86 \r
  87 typedef int16_t Adc_EQADCRegister;\r
  88 \r
  89 typedef enum\r
  90 {\r
  91   ADC0_CR = 1,\r
  92   ADC0_TSCR,\r
  93   ADC0_TBCR,\r
  94   ADC0_GCCR,\r
  95   ADC0_OCCR\r
  96 }Adc_EQADCRegisterType;\r
  97 \r
  98 /* Command queue for calibration sequence. See 31.5.6 in reference manual. */\r
  99 const Adc_CommandType AdcCalibrationCommandQueue [] =\r
 100 {\r
 101   /* Four samples of 25 % of (VRh - VRl). */\r
 102   {\r
 103         .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
 104         .B.CHANNEL_NUMBER = 44\r
 105   },\r
 106   {\r
 107     .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
 108     .B.CHANNEL_NUMBER = 44\r
 109   },\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   /* Four samples of 75 % of (VRh - VRl). */\r
 119   {\r
 120     .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
 121     .B.CHANNEL_NUMBER = 43\r
 122   },\r
 123   {\r
 124     .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
 125     .B.CHANNEL_NUMBER = 43\r
 126   },\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 = 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
 133     .B.CHANNEL_NUMBER = 43\r
 134   }\r
 135 };\r
 136 \r
 137 /* DMA configuration for calibration sequence. */\r
 138 const Dma_TcdType AdcCalibrationDMACommandConfig =\r
 139 {\r
 140   .SADDR = (uint32_t)AdcCalibrationCommandQueue,\r
 141   .SMOD = 0,\r
 142   .SSIZE = DMA_TRANSFER_SIZE_32BITS,\r
 143   .DMOD = 0,\r
 144   .DSIZE = DMA_TRANSFER_SIZE_32BITS,\r
 145   .SOFF = sizeof(Adc_CommandType),\r
 146   .NBYTESu.B.NBYTES = sizeof(Adc_CommandType),\r
 147   .SLAST = 0,\r
 148   .DADDR = (vint32_t)&EQADC.CFPR[0].R,\r
 149   .CITERE_LINK = 0,\r
 150   .CITER = 0,\r
 151   .DOFF = 0,\r
 152   .DLAST_SGA = 0,\r
 153   .BITERE_LINK = 0,\r
 154   .BITER = 0,\r
 155   .BWC = 0,\r
 156   .MAJORLINKCH = 0,\r
 157   .DONE = 0,\r
 158   .ACTIVE = 0,\r
 159   .MAJORE_LINK = 0,\r
 160   .E_SG = 0,\r
 161   .D_REQ = 0,\r
 162   .INT_HALF = 0,\r
 163   .INT_MAJ = 0,\r
 164   .START = 0,\r
 165 };\r
 166 \r
 167 const Dma_TcdType AdcCalibrationDMAResultConfig =\r
 168 {\r
 169   .SADDR = (vint32_t)&EQADC.RFPR[0].R + 2,\r
 170   .SMOD = 0,\r
 171   .SSIZE = DMA_TRANSFER_SIZE_16BITS,\r
 172   .DMOD = 0,\r
 173   .DSIZE = DMA_TRANSFER_SIZE_16BITS,\r
 174   .SOFF = 0,\r
 175   .NBYTESu.B.NBYTES = sizeof(Adc_ValueGroupType),\r
 176   .SLAST = 0,\r
 177   .DADDR = 0, /* Dynamic address, written later. */\r
 178   .CITERE_LINK = 0,\r
 179   .CITER = 0,\r
 180   .DOFF = sizeof(Adc_ValueGroupType),\r
 181   .DLAST_SGA = 0,\r
 182   .BITERE_LINK = 0,\r
 183   .BITER = 0,\r
 184   .BWC = 0,\r
 185   .MAJORLINKCH = 0,\r
 186   .DONE = 0,\r
 187   .ACTIVE = 0,\r
 188   .MAJORE_LINK = 0,\r
 189   .E_SG = 0,\r
 190   .D_REQ = 0,\r
 191   .INT_HALF = 0,\r
 192   .INT_MAJ = 0,\r
 193   .START = 0\r
 194 };\r
 195 \r
 196 typedef enum\r
 197 {\r
 198   ADC_UNINIT,\r
 199   ADC_INIT,\r
 200 }Adc_StateType;\r
 201 \r
 202 /* Function prototypes. */\r
 203 static void Adc_ConfigureEQADC (const Adc_ConfigType *ConfigPtr);\r
 204 static void Adc_ConfigureEQADCInterrupts (void);\r
 205 static void Adc_EQADCCalibrationSequence (void);\r
 206 static void Adc_WriteEQADCRegister (Adc_EQADCRegisterType reg, Adc_EQADCRegister value);\r
 207 static Adc_EQADCRegister Adc_ReadEQADCRegister (Adc_EQADCRegisterType reg);\r
 208 \r
 209 void Adc_GroupConversionComplete (Adc_GroupType group);\r
 210 \r
 211 /* Development error checking. */\r
 212 static Std_ReturnType Adc_CheckReadGroup (Adc_GroupType group);\r
 213 static Std_ReturnType Adc_CheckStartGroupConversion (Adc_GroupType group);\r
 214 static Std_ReturnType Adc_CheckStopGroupConversion (Adc_GroupType group);\r
 215 static Std_ReturnType Adc_CheckInit (const Adc_ConfigType *ConfigPtr);\r
 216 #if (ADC_DEINIT_API == STD_ON)\r
 217 static Std_ReturnType Adc_CheckDeInit (void);\r
 218 #endif\r
 219 static Std_ReturnType Adc_CheckSetupResultBuffer (Adc_GroupType group);\r
 220 static Std_ReturnType Adc_CheckGetStreamLastPointer (Adc_GroupType group);\r
 221 \r
 222 /* static variable declarations */\r
 223 static Adc_StateType adcState = ADC_UNINIT;\r
 224 static const Adc_ConfigType *AdcConfigPtr;      /* Pointer to configuration structure. */\r
 225 \r
 226 /* Validate functions used for development error check */\r
 227 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
 228 Std_ReturnType ValidateInit(Adc_APIServiceIDType api)\r
 229 {\r
 230         Std_ReturnType res = E_OK;\r
 231         if(!(ADC_INIT == adcState)) {\r
 232                 Det_ReportError(MODULE_ID_ADC,0,api,ADC_E_UNINIT );\r
 233                 res = E_NOT_OK;\r
 234         }\r
 235         return res;\r
 236 }\r
 237 Std_ReturnType ValidateGroup(Adc_GroupType group,Adc_APIServiceIDType api)\r
 238 {\r
 239         Std_ReturnType res = E_OK;\r
 240         if(!((group >= 0) && (group < AdcConfig->nbrOfGroups))) {\r
 241                 Det_ReportError(MODULE_ID_ADC,0,api,ADC_E_PARAM_GROUP );\r
 242                 res = E_NOT_OK;\r
 243         }\r
 244         return res;\r
 245 }\r
 246 #endif\r
 247 \r
 248 #if (ADC_DEINIT_API == STD_ON)\r
 249 Std_ReturnType Adc_DeInit (const Adc_ConfigType *ConfigPtr)\r
 250 {\r
 251   (void)ConfigPtr;\r
 252 \r
 253   Adc_eQADCQueueType queue;\r
 254   Adc_GroupType group;\r
 255   boolean queueStopped;\r
 256 \r
 257   if (E_OK == Adc_CheckDeInit())\r
 258   {\r
 259     /* Stop all queues. */\r
 260     for (queue = ADC_EQADC_QUEUE_0; queue < ADC_EQADC_NBR_OF_QUEUES; queue++)\r
 261     {\r
 262       /* Disable queue. */\r
 263       EQADC.CFCR[queue].B.MODE = 0;\r
 264 \r
 265       /* Wait for queue to enter idle state. */\r
 266       queueStopped = FALSE;\r
 267       /* TODO replace switch with bit pattern. */\r
 268       while (!queueStopped)\r
 269       {\r
 270         switch (queue)\r
 271         {\r
 272         case ADC_EQADC_QUEUE_0:\r
 273           queueStopped = (EQADC.CFSR.B.CFS0 == EQADC_CFIFO_STATUS_IDLE);\r
 274           break;\r
 275         case ADC_EQADC_QUEUE_1:\r
 276           queueStopped = (EQADC.CFSR.B.CFS1 == EQADC_CFIFO_STATUS_IDLE);\r
 277           break;\r
 278         case ADC_EQADC_QUEUE_2:\r
 279           queueStopped = (EQADC.CFSR.B.CFS2 == EQADC_CFIFO_STATUS_IDLE);\r
 280           break;\r
 281         case ADC_EQADC_QUEUE_3:\r
 282           queueStopped = (EQADC.CFSR.B.CFS3 == EQADC_CFIFO_STATUS_IDLE);\r
 283           break;\r
 284         case ADC_EQADC_QUEUE_4:\r
 285           queueStopped = (EQADC.CFSR.B.CFS4 == EQADC_CFIFO_STATUS_IDLE);\r
 286           break;\r
 287         case ADC_EQADC_QUEUE_5:\r
 288           queueStopped = (EQADC.CFSR.B.CFS5 == EQADC_CFIFO_STATUS_IDLE);\r
 289           break;\r
 290         default :\r
 291           /* We should never get here... Terminate loop. */\r
 292           queueStopped = TRUE;\r
 293           break;\r
 294         }\r
 295       }\r
 296 \r
 297       /* Disable eDMA requests for commands and results. */\r
 298       EQADC.IDCR[queue].B.CFFS = 0;\r
 299       EQADC.IDCR[queue].B.RFDS = 0;\r
 300 \r
 301       /* Disable FIFO fill requests. */\r
 302       EQADC.IDCR[queue].B.CFFE = 0;\r
 303       EQADC.IDCR[queue].B.RFDE = 0;\r
 304 \r
 305       /* Disable interrupts. */\r
 306       EQADC.IDCR[queue].B.RFOIE = 0;\r
 307       EQADC.IDCR[queue].B.CFUIE = 0;\r
 308       EQADC.IDCR[queue].B.TORIE = 0;\r
 309       EQADC.IDCR[queue].B.EOQIE = 0;\r
 310     }\r
 311 \r
 312     /* Stop all DMA channels connected to EQADC. */\r
 313     for (group = ADC_GROUP0; group < AdcConfigPtr->nbrOfGroups; group++)\r
 314     {\r
 315       Dma_StopChannel (AdcConfigPtr->groupConfigPtr [group].dmaCommandChannel);\r
 316       Dma_StopChannel (AdcConfigPtr->groupConfigPtr [group].dmaResultChannel);\r
 317 \r
 318       /* Set group status to idle. */\r
 319       AdcConfigPtr->groupConfigPtr[group].status->groupStatus = ADC_IDLE;\r
 320     }\r
 321 \r
 322     /* Disable EQADC. */\r
 323     Adc_WriteEQADCRegister (ADC0_CR, 0);\r
 324 \r
 325     /* Clean internal status. */\r
 326     AdcConfigPtr = (Adc_ConfigType *)NULL;\r
 327     adcState = ADC_UNINIT;\r
 328   }\r
 329   return (E_OK);\r
 330 }\r
 331 #endif\r
 332 \r
 333 Std_ReturnType Adc_Init (const Adc_ConfigType *ConfigPtr)\r
 334 {\r
 335   Std_ReturnType returnValue;\r
 336   Adc_InternalChannelIdType channel;\r
 337   Adc_InternalChannelIdType channelId;\r
 338   Adc_GroupType group;\r
 339   Adc_CommandType *commandQueue;\r
 340   Adc_CommandType command;\r
 341 \r
 342   if (E_OK == Adc_CheckInit(ConfigPtr))\r
 343   {\r
 344     /* First of all, store the location of the configuration data. */\r
 345     AdcConfigPtr = ConfigPtr;\r
 346 \r
 347     /* Start configuring the eQADC queues. */\r
 348     for (group = ADC_GROUP0; group < ConfigPtr->nbrOfGroups; group++)\r
 349     {\r
 350       /* Loop through all channels and make the command queue. */\r
 351       for (channel = 0; channel < ConfigPtr->groupConfigPtr[group].numberOfChannels; channel++)\r
 352       {\r
 353         /* Get physical channel. */\r
 354         channelId = ConfigPtr->groupConfigPtr[group].channelList[channel];\r
 355 \r
 356         commandQueue = ConfigPtr->groupConfigPtr[group].commandBuffer;\r
 357 \r
 358         /* Begin with empty command. */\r
 359         command.R = 0;\r
 360 \r
 361         /* Physical channel number. */\r
 362         command.B.CHANNEL_NUMBER = channelId;\r
 363         /* Sample time. */\r
 364         command.B.LST = ConfigPtr->channelConfigPtr [channel].adcChannelConvTime;\r
 365         /* Calibration feature. */\r
 366         command.B.CAL = ConfigPtr->channelConfigPtr [channel].adcChannelCalibrationEnable;\r
 367         /* Result buffer FIFO. The number of groups must not be greater than the number of queues. */\r
 368         command.B.MESSAGE_TAG = group;\r
 369 \r
 370         /* Write command to command queue. */\r
 371         commandQueue [channel].R = command.R;\r
 372 \r
 373         /* Last channel in group. Write EOQ and configure eQADC FIFO. */\r
 374         if (channel == (ConfigPtr->groupConfigPtr[group].numberOfChannels - 1))\r
 375         {\r
 376           commandQueue [channel].B.EOQ = 1;\r
 377         }\r
 378       }\r
 379     }\r
 380 \r
 381     /* Enable ADC. */\r
 382     Adc_ConfigureEQADC (ConfigPtr);\r
 383 \r
 384     /* Perform calibration of the ADC. */\r
 385     Adc_EQADCCalibrationSequence ();\r
 386 \r
 387     /* Configure DMA channels. */\r
 388     for (group = ADC_GROUP0; group < ConfigPtr->nbrOfGroups; group++)\r
 389     {\r
 390       /* ADC307. */\r
 391       ConfigPtr->groupConfigPtr[group].status->groupStatus = ADC_IDLE;\r
 392 \r
 393       Dma_ConfigureChannel ((Dma_TcdType *)ConfigPtr->groupConfigPtr [group].groupDMAResults, ConfigPtr->groupConfigPtr [group].dmaResultChannel);\r
 394       Dma_ConfigureChannel ((Dma_TcdType *)ConfigPtr->groupConfigPtr [group].groupDMACommands, ConfigPtr->groupConfigPtr [group].dmaCommandChannel);\r
 395     }\r
 396 \r
 397     /* Start DMA channels. */\r
 398     for (group = ADC_GROUP0; group < ConfigPtr->nbrOfGroups; group++)\r
 399     {\r
 400       /* Invalidate queues. */\r
 401       EQADC.CFCR[group].B.CFINV = 1;\r
 402 \r
 403       Dma_StartChannel (ConfigPtr->groupConfigPtr [group].dmaResultChannel);\r
 404       Dma_StartChannel (ConfigPtr->groupConfigPtr [group].dmaCommandChannel);\r
 405     }\r
 406 \r
 407     Adc_ConfigureEQADCInterrupts ();\r
 408 \r
 409     /* Move on to INIT state. */\r
 410     adcState = ADC_INIT;\r
 411     returnValue = E_OK;\r
 412   }\r
 413   else\r
 414   {\r
 415     returnValue = E_NOT_OK;\r
 416   }\r
 417 \r
 418   return (returnValue);  \r
 419 }\r
 420 \r
 421 Std_ReturnType Adc_SetupResultBuffer (Adc_GroupType group, Adc_ValueGroupType *bufferPtr)\r
 422 {\r
 423   Std_ReturnType returnValue = E_NOT_OK;\r
 424 \r
 425   /* Check for development errors. */\r
 426   if (E_OK == Adc_CheckSetupResultBuffer (group))\r
 427   {\r
 428     AdcConfigPtr->groupConfigPtr[group].status->resultBufferPtr = bufferPtr;\r
 429     \r
 430     returnValue = E_OK;\r
 431   }\r
 432 \r
 433   return (returnValue);\r
 434 }\r
 435 \r
 436 Adc_StreamNumSampleType Adc_GetStreamLastPointer(Adc_GroupType group, Adc_ValueGroupType** PtrToSamplePtr)\r
 437 {\r
 438         Adc_StreamNumSampleType nofSample = 0;\r
 439         Adc_GroupDefType *groupPtr = (Adc_GroupDefType *)&AdcConfigPtr->groupConfigPtr[group];\r
 440         \r
 441         /** @req ADC216 */\r
 442         /* Check for development errors. */\r
 443         if ( (E_OK == Adc_CheckGetStreamLastPointer (group)) &&\r
 444                  (groupPtr->status->groupStatus != ADC_BUSY) )\r
 445         {\r
 446             /* Set resultPtr to application buffer. */\r
 447                 if(groupPtr->status->currSampleCount > 0){\r
 448                         *PtrToSamplePtr = &groupPtr->status->resultBufferPtr[groupPtr->status->currSampleCount-1];\r
 449                 }\r
 450 \r
 451             if ((ADC_CONV_MODE_ONESHOT == groupPtr->conversionMode) &&\r
 452                 (ADC_STREAM_COMPLETED  == groupPtr->status->groupStatus))\r
 453             {\r
 454                         /** @req ADC327. */\r
 455                         groupPtr->status->groupStatus = ADC_IDLE;\r
 456             }\r
 457             else if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 458                      (ADC_ACCESS_MODE_STREAMING == groupPtr->accessMode) &&\r
 459                      (ADC_STREAM_BUFFER_LINEAR == groupPtr->streamBufferMode) &&\r
 460                      (ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus))\r
 461             {\r
 462                         /** @req ADC327. */\r
 463                         groupPtr->status->groupStatus = ADC_IDLE;\r
 464             }\r
 465             else if ( (ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 466                       ((ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus) ||\r
 467                        (ADC_COMPLETED           == groupPtr->status->groupStatus)) )\r
 468             {\r
 469                 /* Restart continous mode, and reset result buffer */\r
 470                 if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 471                     (ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus))\r
 472                 {\r
 473                           /* Start continous conversion again */\r
 474                         Adc_StartGroupConversion(group);\r
 475                 }\r
 476                         /** @req ADC326 */\r
 477                         /** @req ADC328 */\r
 478             }\r
 479             else{/* Keep status. */}\r
 480         }\r
 481         else\r
 482         {\r
 483                 /* Some condition not met */\r
 484                 *PtrToSamplePtr = NULL;\r
 485         }\r
 486 \r
 487         return nofSample;\r
 488 \r
 489 }\r
 490 \r
 491 #if (ADC_READ_GROUP_API == STD_ON)\r
 492 Std_ReturnType Adc_ReadGroup (Adc_GroupType group, Adc_ValueGroupType *dataBufferPtr)\r
 493 {\r
 494   Std_ReturnType returnValue = E_OK;\r
 495   uint8_t channel;\r
 496   Adc_GroupDefType *groupPtr = (Adc_GroupDefType *)&AdcConfigPtr->groupConfigPtr[group];\r
 497 \r
 498   if (E_OK == Adc_CheckReadGroup (group))\r
 499   {\r
 500     /* Copy the result to application buffer. */\r
 501     for (channel = 0; channel < groupPtr->numberOfChannels; channel++)\r
 502         {\r
 503                 if(groupPtr->status->currSampleCount > 0){\r
 504                         dataBufferPtr[channel] = (&(groupPtr->status->resultBufferPtr[groupPtr->status->currSampleCount-1]))[channel];\r
 505                 }else{\r
 506                         dataBufferPtr[channel] = groupPtr->status->resultBufferPtr[channel];\r
 507                 }\r
 508         }\r
 509 \r
 510     if ((ADC_CONV_MODE_ONESHOT == groupPtr->conversionMode) &&\r
 511         (ADC_STREAM_COMPLETED  == groupPtr->status->groupStatus))\r
 512     {\r
 513                 /** @req ADC330. */\r
 514                 groupPtr->status->groupStatus = ADC_IDLE;\r
 515     }\r
 516     else if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 517              (ADC_STREAM_BUFFER_LINEAR == groupPtr->streamBufferMode) &&\r
 518              (ADC_ACCESS_MODE_STREAMING == groupPtr->accessMode) &&\r
 519              (ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus))\r
 520     {\r
 521                 /** @req ADC330. */\r
 522                 groupPtr->status->groupStatus = ADC_IDLE;\r
 523     }\r
 524     else if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 525              ((ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus) ||\r
 526               (ADC_COMPLETED           == groupPtr->status->groupStatus)))\r
 527     {\r
 528         /** @req ADC329 */\r
 529       /* Restart continous mode, and reset result buffer */\r
 530       if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 531           (ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus))\r
 532       {\r
 533                   /* Start continous conversion again */\r
 534         Adc_StartGroupConversion(group);\r
 535       }\r
 536       /** @req ADC329 */\r
 537       /** @req ADC331 */\r
 538     }\r
 539     else{/* Keep status. */}\r
 540   }\r
 541   else\r
 542   {\r
 543     /* An error have been raised from Adc_CheckReadGroup(). */\r
 544     returnValue = E_NOT_OK;\r
 545   }\r
 546 \r
 547   return (returnValue);\r
 548 }\r
 549 #endif\r
 550 \r
 551 Adc_StatusType Adc_GetGroupStatus (Adc_GroupType group)\r
 552 {\r
 553         Adc_StatusType returnValue;\r
 554 \r
 555 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
 556         if( (ValidateInit(ADC_GETGROUPSTATUS_ID) == E_NOT_OK) ||\r
 557                 (ValidateGroup(group, ADC_GETGROUPSTATUS_ID) == E_NOT_OK))\r
 558         {\r
 559                 returnValue = ADC_IDLE;\r
 560         }\r
 561         else\r
 562         {\r
 563                 returnValue = AdcConfigPtr->groupConfigPtr[group].status->groupStatus;\r
 564         }\r
 565 #else\r
 566   returnValue = AdcConfigPtr->groupConfigPtr[group].status->groupStatus;\r
 567 #endif\r
 568   return (returnValue);\r
 569 }\r
 570 \r
 571 void Adc_GroupConversionComplete (Adc_GroupType group)\r
 572 {\r
 573         Adc_GroupDefType *adcGroup = (Adc_GroupDefType *)&AdcConfigPtr->groupConfigPtr[group];\r
 574 \r
 575   if(ADC_ACCESS_MODE_SINGLE == adcGroup->accessMode )\r
 576   {\r
 577           adcGroup->status->groupStatus = ADC_STREAM_COMPLETED;\r
 578           /* Call notification if enabled. */\r
 579         #if (ADC_GRP_NOTIF_CAPABILITY == STD_ON)\r
 580           if (adcGroup->status->notifictionEnable && adcGroup->groupCallback != NULL)\r
 581           {\r
 582                   adcGroup->groupCallback();\r
 583           }\r
 584         #endif\r
 585                   /* Disable trigger. */\r
 586                   EQADC.CFCR[group].B.MODE = 0;\r
 587   }\r
 588   else\r
 589   {\r
 590         if(ADC_STREAM_BUFFER_LINEAR == adcGroup->streamBufferMode)\r
 591         {\r
 592                 adcGroup->status->currSampleCount++;\r
 593                 if(adcGroup->status->currSampleCount < adcGroup->streamNumSamples)\r
 594                 {\r
 595                   adcGroup->status->currResultBufPtr += adcGroup->numberOfChannels;\r
 596                   adcGroup->status->groupStatus = ADC_COMPLETED;\r
 597 \r
 598 #if defined (ADC_USES_DMA)\r
 599                   /* Increase current result buffer ptr */\r
 600                 Dma_ConfigureDestinationAddress((uint32_t)adcGroup->status->currResultBufPtr, adcGroup->dmaResultChannel);\r
 601 #endif\r
 602 \r
 603                 /* Set single scan enable bit */\r
 604                 EQADC.CFCR[group].B.SSE = 1;\r
 605                 }\r
 606                 else\r
 607                 {\r
 608                   /* All sample completed. */\r
 609                   adcGroup->status->groupStatus = ADC_STREAM_COMPLETED;\r
 610 \r
 611                   /* Call notification if enabled. */\r
 612                 #if (ADC_GRP_NOTIF_CAPABILITY == STD_ON)\r
 613                   if (adcGroup->status->notifictionEnable && adcGroup->groupCallback != NULL){\r
 614                         adcGroup->groupCallback();\r
 615                   }\r
 616                 #endif\r
 617                   /* Disable trigger. */\r
 618                   EQADC.CFCR[group].B.MODE = 0;\r
 619                 }\r
 620         }\r
 621         else if(ADC_STREAM_BUFFER_CIRCULAR == adcGroup->streamBufferMode)\r
 622         {\r
 623                 adcGroup->status->currSampleCount++;\r
 624                 if(adcGroup->status->currSampleCount < adcGroup->streamNumSamples)\r
 625                 {\r
 626                         adcGroup->status->currResultBufPtr += adcGroup->numberOfChannels;\r
 627 #if defined (ADC_USES_DMA)\r
 628                         /* Increase current result buffer ptr */\r
 629                         Dma_ConfigureDestinationAddress((uint32_t)adcGroup->status->currResultBufPtr, adcGroup->dmaResultChannel);\r
 630 #endif\r
 631                         adcGroup->status->groupStatus = ADC_COMPLETED;\r
 632 \r
 633                         /* Set single scan enable bit */\r
 634                         EQADC.CFCR[group].B.SSE = 1;\r
 635                 }\r
 636                 else\r
 637                 {\r
 638                   /* Sample completed. */\r
 639                   /* Disable trigger. */\r
 640                   EQADC.CFCR[group].B.MODE = 0;\r
 641                   adcGroup->status->groupStatus = ADC_STREAM_COMPLETED;\r
 642                   /* Call notification if enabled. */\r
 643                 #if (ADC_GRP_NOTIF_CAPABILITY == STD_ON)\r
 644                   if (adcGroup->status->notifictionEnable && adcGroup->groupCallback != NULL)\r
 645                   {\r
 646                           adcGroup->groupCallback();\r
 647                   }\r
 648                 #endif\r
 649                 }\r
 650         }\r
 651         else\r
 652         {\r
 653                 //nothing to do.\r
 654         }\r
 655   }\r
 656 }\r
 657 \r
 658 void Adc_Group0ConversionComplete (void)\r
 659 {\r
 660   /* ISR for FIFO 0 end of queue. Clear interrupt flag.  */\r
 661   EQADC.FISR[ADC_EQADC_QUEUE_0].B.EOQF = 1;\r
 662   Adc_GroupConversionComplete(0);\r
 663 }\r
 664 void Adc_Group1ConversionComplete (void)\r
 665 {\r
 666   /* ISR for FIFO 0 end of queue. Clear interrupt flag.  */\r
 667   EQADC.FISR[ADC_EQADC_QUEUE_1].B.EOQF = 1;\r
 668   Adc_GroupConversionComplete(1);\r
 669 }\r
 670 void Adc_Group2ConversionComplete (void)\r
 671 {\r
 672   /* ISR for FIFO 0 end of queue. Clear interrupt flag.  */\r
 673   EQADC.FISR[ADC_EQADC_QUEUE_2].B.EOQF = 1;\r
 674   Adc_GroupConversionComplete(2);\r
 675 }\r
 676 void Adc_Group3ConversionComplete (void)\r
 677 {\r
 678   /* ISR for FIFO 0 end of queue. Clear interrupt flag.  */\r
 679   EQADC.FISR[ADC_EQADC_QUEUE_3].B.EOQF = 1;\r
 680   Adc_GroupConversionComplete(3);\r
 681 }\r
 682 void Adc_Group4ConversionComplete (void)\r
 683 {\r
 684   /* ISR for FIFO 0 end of queue. Clear interrupt flag.  */\r
 685   EQADC.FISR[ADC_EQADC_QUEUE_4].B.EOQF = 1;\r
 686   Adc_GroupConversionComplete(4);\r
 687 }\r
 688 void Adc_Group5ConversionComplete (void)\r
 689 {\r
 690   /* ISR for FIFO 0 end of queue. Clear interrupt flag.  */\r
 691   EQADC.FISR[ADC_EQADC_QUEUE_5].B.EOQF = 1;\r
 692   Adc_GroupConversionComplete(5);\r
 693 }\r
 694 \r
 695 void Adc_EQADCError (void)\r
 696 {\r
 697   /* Something is wrong!! Check the cause of the error and try to correct it. */\r
 698   if (EQADC.FISR[ADC_EQADC_QUEUE_0].B.TORF)\r
 699   {\r
 700     /* Trigger overrun on queue 0!! */\r
 701     assert (0);\r
 702   }\r
 703   else if (EQADC.FISR[ADC_EQADC_QUEUE_1].B.TORF)\r
 704   {\r
 705     /* Trigger overrun on queue 1!! */\r
 706     assert (0);\r
 707   }\r
 708   else if (EQADC.FISR[ADC_EQADC_QUEUE_0].B.CFUF)\r
 709   {\r
 710     /* Command underflow on queue 0!! */\r
 711     assert (0);\r
 712   }\r
 713   else if (EQADC.FISR[ADC_EQADC_QUEUE_1].B.CFUF)\r
 714   {\r
 715     /* Command underflow on queue 1!! */\r
 716     assert (0);\r
 717   }\r
 718   else if (EQADC.FISR[ADC_EQADC_QUEUE_0].B.RFOF)\r
 719   {\r
 720     /* Result overflow on queue 0!! */\r
 721     assert (0);\r
 722   }\r
 723   else if (EQADC.FISR[ADC_EQADC_QUEUE_1].B.RFOF)\r
 724   {\r
 725     /* Result overflow on queue 1!! */\r
 726     assert (0);\r
 727   }\r
 728   else\r
 729   {\r
 730     /* Something else... TODO What have we missed above */\r
 731     assert(0);\r
 732   }\r
 733 }\r
 734 \r
 735 /* Helper macro to make sure that the qommand queue have\r
 736  * executed the commands in the fifo.\r
 737  * First check that the H/W negate the\r
 738  * single scan bit and then wait for EOQ. */\r
 739 #define WAIT_FOR_QUEUE_TO_FINISH(q) \\r
 740   while (EQADC.FISR[q].B.SSS)             \\r
 741   {                                       \\r
 742     ;                                     \\r
 743   }                                       \\r
 744                                           \\r
 745   while (!EQADC.FISR[q].B.EOQF)           \\r
 746   {                                       \\r
 747     ;                                     \\r
 748   }\r
 749 \r
 750 static void Adc_WriteEQADCRegister (Adc_EQADCRegisterType reg, Adc_EQADCRegister value)\r
 751 {\r
 752   Adc_RegisterWriteType writeReg;\r
 753   uint32_t temp, oldMode;\r
 754 \r
 755   writeReg.R = 0;\r
 756 \r
 757   /* Write command. */\r
 758   writeReg.B.RW = 0;\r
 759   writeReg.B.EOQ = 1;\r
 760   writeReg.B.ADC_REG = value;\r
 761   writeReg.B.ADC_REG_ADDR = reg;\r
 762 \r
 763   /* Invalidate queue. */\r
 764   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.CFINV = 1;\r
 765 \r
 766 \r
 767   /* Write command through FIFO. */\r
 768   EQADC.CFPR[ADC_EQADC_QUEUE_0].R = writeReg.R;\r
 769 \r
 770   /* Enable FIFO. */\r
 771   oldMode = EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE;\r
 772   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE = ADC_CONV_MODE_ONESHOT;\r
 773   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.SSE = 1;\r
 774 \r
 775   /* Wait for command to be executed. */\r
 776   WAIT_FOR_QUEUE_TO_FINISH(ADC_EQADC_QUEUE_0);\r
 777 \r
 778   /* Flush result buffer. */\r
 779   temp = EQADC.RFPR[ADC_EQADC_QUEUE_0].R;\r
 780   EQADC.FISR[ADC_EQADC_QUEUE_0].B.EOQF = 1;\r
 781 \r
 782   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE = oldMode;\r
 783 \r
 784 }\r
 785 \r
 786 static Adc_EQADCRegister Adc_ReadEQADCRegister (Adc_EQADCRegisterType reg)\r
 787 {\r
 788   Adc_RegisterReadType readReg;\r
 789   Adc_EQADCRegister result;\r
 790   uint32_t oldMode, dmaRequestEnable;\r
 791 \r
 792   readReg.R = 0;\r
 793 \r
 794   /* Read command. */\r
 795   readReg.B.RW = 1;\r
 796   readReg.B.EOQ = 1;\r
 797   readReg.B.ADC_REG_ADDR = reg;\r
 798   readReg.B.MESSAGE_TAG = ADC_EQADC_QUEUE_0;\r
 799 \r
 800   /* Make sure that DMA requests for command fill and result drain is disabled. */\r
 801   if (EQADC.IDCR[ADC_EQADC_QUEUE_0].B.RFDE || EQADC.IDCR[ADC_EQADC_QUEUE_0].B.CFFE)\r
 802   {\r
 803     EQADC.IDCR[ADC_EQADC_QUEUE_0].B.CFFE = 0;\r
 804     EQADC.IDCR[ADC_EQADC_QUEUE_0].B.RFDE = 0;\r
 805 \r
 806     /* Remember to enable requests again... */\r
 807     dmaRequestEnable = TRUE;\r
 808   }\r
 809   else\r
 810   {\r
 811     dmaRequestEnable = FALSE;\r
 812   }\r
 813 \r
 814   /* Invalidate queue. */\r
 815   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.CFINV = 1;\r
 816 \r
 817   /* Write command through FIFO. */\r
 818   EQADC.CFPR[ADC_EQADC_QUEUE_0].R = readReg.R;\r
 819 \r
 820   /* Enable FIFO. */\r
 821   oldMode = EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE;\r
 822   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE = ADC_CONV_MODE_ONESHOT;\r
 823   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.SSE = 1;\r
 824 \r
 825   /* Wait for command to be executed. */\r
 826   WAIT_FOR_QUEUE_TO_FINISH(ADC_EQADC_QUEUE_0);\r
 827 \r
 828   /* Read result buffer. */\r
 829   result = EQADC.RFPR[ADC_EQADC_QUEUE_0].R;\r
 830   EQADC.FISR[ADC_EQADC_QUEUE_0].B.EOQF = 1;\r
 831 \r
 832   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE = oldMode;\r
 833 \r
 834   if (dmaRequestEnable)\r
 835   {\r
 836     EQADC.IDCR[ADC_EQADC_QUEUE_0].B.CFFE = 1;\r
 837     EQADC.IDCR[ADC_EQADC_QUEUE_0].B.RFDE = 1;\r
 838   }\r
 839   else\r
 840   {\r
 841     /* Do nothing. */\r
 842   }\r
 843   return (result);\r
 844 }\r
 845 static void  Adc_ConfigureEQADC (const Adc_ConfigType *ConfigPtr)\r
 846 {\r
 847   Adc_GroupType group;\r
 848 \r
 849   enum\r
 850   {\r
 851     ADC_ENABLE = 0x8000,\r
 852   };\r
 853   /* Enable ADC0. */\r
 854   Adc_WriteEQADCRegister (ADC0_CR, (ADC_ENABLE | ConfigPtr->hwConfigPtr->adcPrescale));\r
 855 \r
 856   /* Disable time stamp timer. */\r
 857   Adc_WriteEQADCRegister (ADC0_TSCR, 0);\r
 858 \r
 859   for (group = ADC_GROUP0; group < ConfigPtr->nbrOfGroups; group++)\r
 860   {\r
 861     /* Enable eDMA requests for commands and results. */\r
 862     EQADC.IDCR[group].B.CFFS = 1;\r
 863     EQADC.IDCR[group].B.RFDS = 1;\r
 864 \r
 865     /* Invalidate FIFO. */\r
 866     EQADC.CFCR[group].B.CFINV = 1;\r
 867 \r
 868     /* Enable FIFO fill requests. */\r
 869     EQADC.IDCR[group].B.CFFE = 1;\r
 870     EQADC.IDCR[group].B.RFDE = 1;\r
 871   }\r
 872 }\r
 873 \r
 874 void Adc_ConfigureEQADCInterrupts (void)\r
 875 {\r
 876   Adc_GroupType group;\r
 877   ISR_INSTALL_ISR2( "Adc_Err", Adc_EQADCError, EQADC_FISR_OVER,     2, 0);\r
 878   for (group = ADC_GROUP0; group < AdcConfigPtr->nbrOfGroups; group++)\r
 879   {\r
 880     /* Enable end of queue, queue overflow/underflow interrupts. Clear corresponding flags. */\r
 881     EQADC.FISR[group].B.RFOF = 1;\r
 882     EQADC.IDCR[group].B.RFOIE = 1;\r
 883 \r
 884     EQADC.FISR[group].B.CFUF = 1;\r
 885     EQADC.IDCR[group].B.CFUIE = 1;\r
 886 \r
 887     EQADC.FISR[group].B.TORF = 1;\r
 888     EQADC.IDCR[group].B.TORIE = 1;\r
 889 \r
 890     EQADC.FISR[group].B.EOQF = 1;\r
 891     EQADC.IDCR[group].B.EOQIE = 1;\r
 892     if(group == 0){\r
 893         ISR_INSTALL_ISR2( "Adc_Grp0", Adc_Group0ConversionComplete, EQADC_FISR0_EOQF0,     2, 0);\r
 894     }else if(group == 1){\r
 895         ISR_INSTALL_ISR2( "Adc_Grp1", Adc_Group1ConversionComplete, EQADC_FISR1_EOQF1,     2, 0);\r
 896         }else if(group == 2){\r
 897                 ISR_INSTALL_ISR2( "Adc_Grp2", Adc_Group2ConversionComplete, EQADC_FISR2_EOQF2,     2, 0);\r
 898         }else if(group == 3){\r
 899                 ISR_INSTALL_ISR2( "Adc_Grp3", Adc_Group3ConversionComplete, EQADC_FISR3_EOQF3,     2, 0);\r
 900         }else if(group == 4){\r
 901                 ISR_INSTALL_ISR2( "Adc_Grp4", Adc_Group4ConversionComplete, EQADC_FISR4_EOQF4,     2, 0);\r
 902         }else if(group == 5){\r
 903                 ISR_INSTALL_ISR2( "Adc_Grp5", Adc_Group5ConversionComplete, EQADC_FISR5_EOQF5,     2, 0);\r
 904         }\r
 905   }\r
 906 }\r
 907 \r
 908 #if (ADC_ENABLE_START_STOP_GROUP_API == STD_ON)\r
 909 void Adc_StartGroupConversion (Adc_GroupType group)\r
 910 {\r
 911         Adc_GroupDefType *groupPtr = (Adc_GroupDefType *)&AdcConfigPtr->groupConfigPtr[group];\r
 912 \r
 913         /* Run development error check. */\r
 914         if (E_OK == Adc_CheckStartGroupConversion (group))\r
 915         {\r
 916         /* Disable trigger. */\r
 917         EQADC.CFCR[group].B.MODE = 0;\r
 918 \r
 919         /* Set group state to BUSY. */\r
 920                 groupPtr->status->groupStatus = ADC_BUSY;\r
 921 \r
 922                 groupPtr->status->currSampleCount = 0;\r
 923                 groupPtr->status->currResultBufPtr = groupPtr->status->resultBufferPtr; /* Set current result buffer */\r
 924 \r
 925                 Dma_ConfigureDestinationAddress((uint32_t)groupPtr->status->resultBufferPtr, groupPtr->dmaResultChannel);\r
 926 \r
 927                 /* Always use single shot in streaming mode */\r
 928                 if( groupPtr->accessMode == ADC_ACCESS_MODE_STREAMING)\r
 929                 {\r
 930                         /* Set conversion mode. */\r
 931                         EQADC.CFCR[group].B.MODE = ADC_CONV_MODE_ONESHOT;\r
 932                         /* Set single scan enable bit if this group is one shot. */\r
 933                         EQADC.CFCR[group].B.SSE = 1;\r
 934                 }\r
 935                 else\r
 936                 {\r
 937                         /* Set conversion mode. */\r
 938                         EQADC.CFCR[group].B.MODE = groupPtr->conversionMode;\r
 939                         /* Set single scan enable bit if this group is one shot. */\r
 940                         if (AdcConfigPtr->groupConfigPtr[group].conversionMode == ADC_CONV_MODE_ONESHOT)\r
 941                         {\r
 942                           EQADC.CFCR[group].B.SSE = 1;\r
 943                         }\r
 944                 }\r
 945         }\r
 946         else\r
 947         {\r
 948         /* Error have been set within Adc_CheckStartGroupConversion(). */\r
 949         }\r
 950 }\r
 951 \r
 952 void Adc_StopGroupConversion (Adc_GroupType group)\r
 953 {\r
 954         if (E_OK == Adc_CheckStopGroupConversion (group))\r
 955         {\r
 956                 uint32 groupMask = 0x3 << (group * 2);\r
 957                 /* Disable trigger normal conversions for ADC */\r
 958                 EQADC.CFCR[group].B.MODE = 0;\r
 959                 while((EQADC.CFSR.R & groupMask) != EQADC_CFIFO_STATUS_IDLE);\r
 960 \r
 961                 /* Invalidate FIFO. */\r
 962                 EQADC.CFCR[group].B.CFINV = 1;\r
 963 \r
 964                 /* Set group state to IDLE. */\r
 965                 AdcConfigPtr->groupConfigPtr[group].status->groupStatus = ADC_IDLE;\r
 966 \r
 967                 /* Disable group notification if enabled. */\r
 968                 if(1 == AdcConfigPtr->groupConfigPtr[group].status->notifictionEnable){\r
 969                         Adc_DisableGroupNotification (group);\r
 970                 }\r
 971         }\r
 972         else\r
 973         {\r
 974         /* Error have been set within Adc_CheckStartGroupConversion(). */\r
 975         }\r
 976 }\r
 977 #endif\r
 978 \r
 979 static void Adc_EQADCCalibrationSequence (void)\r
 980 {\r
 981   Adc_ValueGroupType calibrationResult[sizeof(AdcCalibrationCommandQueue)/sizeof(AdcCalibrationCommandQueue[0])];\r
 982   int32_t point25Average, point75Average, i;\r
 983   Adc_EQADCRegister tempGCC, tempOCC;\r
 984   enum\r
 985   {\r
 986     IDEAL_RES25 = 0x1000,\r
 987     IDEAL_RES75 = 0x3000,\r
 988   };\r
 989 \r
 990   /* Use group 0 DMA channel for calibration. */\r
 991   Dma_ConfigureChannel ((Dma_TcdType *)&AdcCalibrationDMACommandConfig,DMA_ADC_GROUP0_COMMAND_CHANNEL);\r
 992   Dma_ConfigureChannelTranferSize (sizeof(AdcCalibrationCommandQueue)/sizeof(AdcCalibrationCommandQueue[0]),\r
 993                                            DMA_ADC_GROUP0_COMMAND_CHANNEL);\r
 994   Dma_ConfigureChannelSourceCorr (-sizeof(AdcCalibrationCommandQueue), DMA_ADC_GROUP0_COMMAND_CHANNEL);\r
 995 \r
 996   Dma_ConfigureChannel ((Dma_TcdType *)&AdcCalibrationDMAResultConfig, DMA_ADC_GROUP0_RESULT_CHANNEL);\r
 997   Dma_ConfigureChannelTranferSize (sizeof(calibrationResult)/sizeof(calibrationResult[0]),\r
 998                                            DMA_ADC_GROUP0_RESULT_CHANNEL);\r
 999   Dma_ConfigureChannelDestinationCorr (-sizeof(calibrationResult), DMA_ADC_GROUP0_RESULT_CHANNEL);\r
1000   Dma_ConfigureDestinationAddress ((uint32_t)calibrationResult, DMA_ADC_GROUP0_RESULT_CHANNEL);\r
1001 \r
1002   /* Invalidate queues. */\r
1003   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.CFINV = 1;\r
1004 \r
1005   Dma_StartChannel (DMA_ADC_GROUP0_COMMAND_CHANNEL);\r
1006   Dma_StartChannel (DMA_ADC_GROUP0_RESULT_CHANNEL);\r
1007 \r
1008   /* Start conversion. */\r
1009   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE = ADC_CONV_MODE_ONESHOT;\r
1010   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.SSE = 1;\r
1011 \r
1012   /* Wait for conversion to complete. */\r
1013   while(!Dma_ChannelDone (DMA_ADC_GROUP0_RESULT_CHANNEL))\r
1014   {\r
1015     ;\r
1016   }\r
1017 \r
1018   /* Stop DMA channels and write calibration data to ADC engine. */\r
1019   EQADC.CFCR[ADC_EQADC_QUEUE_0].B.MODE = ADC_CONV_MODE_DISABLED;\r
1020   Dma_StopChannel (DMA_ADC_GROUP0_COMMAND_CHANNEL);\r
1021   Dma_StopChannel (DMA_ADC_GROUP0_RESULT_CHANNEL);\r
1022 \r
1023   /* Calculate conversion factors and write to ADC. */\r
1024   point25Average = 0;\r
1025   point75Average = 0;\r
1026   for (i = 0; i < sizeof(calibrationResult)/sizeof(calibrationResult[0] / 2); i++)\r
1027   {\r
1028     point25Average += calibrationResult[i];\r
1029     point75Average += calibrationResult[i + sizeof(calibrationResult)/sizeof(calibrationResult[0]) / 2];\r
1030   }\r
1031 \r
1032   /* Calculate average and correction slope and offset.  */\r
1033   point25Average /= (sizeof(calibrationResult)/sizeof(calibrationResult[0]) / 2);\r
1034   point75Average /= (sizeof(calibrationResult)/sizeof(calibrationResult[0]) / 2);\r
1035 \r
1036   tempGCC = ((IDEAL_RES75 - IDEAL_RES25) << 14) / (point75Average - point25Average);\r
1037   tempOCC = IDEAL_RES75 - ((tempGCC * point75Average) >> 14) - 2;\r
1038 \r
1039   /* GCC field is only 15 bits. */\r
1040   tempGCC = tempGCC & ~(1 << 15);\r
1041 \r
1042   /* OCC field is only 14 bits. */\r
1043   tempOCC = tempOCC & ~(3 << 14);\r
1044 \r
1045   /* Write calibration data to ADC engine. */\r
1046   Adc_WriteEQADCRegister (ADC0_GCCR, tempGCC);\r
1047   Adc_WriteEQADCRegister (ADC0_OCCR, tempOCC);\r
1048 \r
1049   /* Read back and check calibration values. */\r
1050   if (Adc_ReadEQADCRegister (ADC0_GCCR) != tempGCC)\r
1051   {\r
1052     assert (0);\r
1053   }\r
1054   else if (Adc_ReadEQADCRegister (ADC0_OCCR) != tempOCC)\r
1055   {\r
1056     assert (0);\r
1057   }\r
1058 }\r
1059 \r
1060 #define SYSTEM_CLOCK_DIVIDE(f)    ((f / 2) - 1)\r
1061 \r
1062 #if (ADC_GRP_NOTIF_CAPABILITY == STD_ON)\r
1063 void Adc_EnableGroupNotification (Adc_GroupType group)\r
1064 {\r
1065         Std_ReturnType res;\r
1066 \r
1067 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1068         if( (ValidateInit(ADC_ENABLEGROUPNOTIFICATION_ID) == E_NOT_OK) ||\r
1069                 (ValidateGroup(group, ADC_ENABLEGROUPNOTIFICATION_ID) == E_NOT_OK))\r
1070         {\r
1071                 res = E_NOT_OK;\r
1072         }\r
1073         else if (AdcConfigPtr->groupConfigPtr[group].groupCallback == NULL)\r
1074         {\r
1075                 res = E_NOT_OK;\r
1076                 Det_ReportError(MODULE_ID_ADC,0,ADC_ENABLEGROUPNOTIFICATION_ID ,ADC_E_NOTIF_CAPABILITY );\r
1077         }\r
1078         else\r
1079         {\r
1080                 /* Nothing strange. Go on... */\r
1081                 res = E_OK;\r
1082         }\r
1083 #else\r
1084         res = E_OK;\r
1085 #endif\r
1086         if (E_OK == res){\r
1087                 AdcConfigPtr->groupConfigPtr[group].status->notifictionEnable = 1;\r
1088         }\r
1089 }\r
1090 \r
1091 void Adc_DisableGroupNotification (Adc_GroupType group)\r
1092 {\r
1093         Std_ReturnType res;\r
1094 \r
1095 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1096         if( (ValidateInit(ADC_DISABLEGROUPNOTIFICATION_ID) == E_NOT_OK) ||\r
1097                 (ValidateGroup(group, ADC_DISABLEGROUPNOTIFICATION_ID) == E_NOT_OK))\r
1098         {\r
1099                 res = E_NOT_OK;\r
1100         }\r
1101         else if (AdcConfigPtr->groupConfigPtr[group].groupCallback == NULL)\r
1102         {\r
1103                 res = E_NOT_OK;\r
1104                 Det_ReportError(MODULE_ID_ADC,0,ADC_DISABLEGROUPNOTIFICATION_ID ,ADC_E_NOTIF_CAPABILITY );\r
1105         }\r
1106         else\r
1107         {\r
1108                 /* Nothing strange. Go on... */\r
1109                 res = E_OK;\r
1110         }\r
1111 #else\r
1112         res = E_OK;\r
1113 #endif\r
1114         if (E_OK == res){\r
1115                 AdcConfigPtr->groupConfigPtr[group].status->notifictionEnable = 0;\r
1116         }\r
1117 }\r
1118 #endif\r
1119 \r
1120 \r
1121 \r
1122 /* Development error checking functions. */\r
1123 #if (ADC_READ_GROUP_API == STD_ON)\r
1124 static Std_ReturnType Adc_CheckReadGroup (Adc_GroupType group)\r
1125 {\r
1126   Std_ReturnType returnValue = E_OK;\r
1127 \r
1128 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1129 \r
1130   if( (ValidateInit(ADC_READGROUP_ID) == E_NOT_OK) ||\r
1131       (ValidateGroup(group, ADC_READGROUP_ID) == E_NOT_OK))\r
1132   {\r
1133           returnValue = E_NOT_OK;\r
1134   }\r
1135   else if (ADC_IDLE == AdcConfigPtr->groupConfigPtr[group].status->groupStatus)\r
1136   {\r
1137     /* ADC388. */\r
1138     returnValue = E_NOT_OK;\r
1139     Det_ReportError(MODULE_ID_ADC,0,ADC_READGROUP_ID ,ADC_E_IDLE );\r
1140   }\r
1141   else\r
1142   {\r
1143     /* Nothing strange. Go on... */\r
1144     returnValue = E_OK;\r
1145   }\r
1146 #endif\r
1147   return (returnValue);\r
1148 }\r
1149 #endif\r
1150 \r
1151 #if (ADC_ENABLE_START_STOP_GROUP_API == STD_ON)\r
1152 static Std_ReturnType Adc_CheckStartGroupConversion (Adc_GroupType group)\r
1153 {\r
1154   Std_ReturnType returnValue = E_OK;\r
1155 \r
1156 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1157 \r
1158   if( (ValidateInit(ADC_STARTGROUPCONVERSION_ID) == E_NOT_OK) ||\r
1159       (ValidateGroup(group, ADC_STARTGROUPCONVERSION_ID) == E_NOT_OK))\r
1160   {\r
1161           returnValue = E_NOT_OK;\r
1162   }\r
1163   else if ( NULL == AdcConfigPtr->groupConfigPtr[group].status->resultBufferPtr )\r
1164   {\r
1165       /* ResultBuffer not set, ADC424 */\r
1166           Det_ReportError(MODULE_ID_ADC,0,ADC_STARTGROUPCONVERSION_ID, ADC_E_BUFFER_UNINIT );\r
1167           returnValue = E_NOT_OK;\r
1168   }\r
1169   else if (!(ADC_TRIGG_SRC_SW == AdcConfigPtr->groupConfigPtr[group].triggerSrc))\r
1170   {\r
1171     /* Wrong trig source, ADC133. */\r
1172     Det_ReportError(MODULE_ID_ADC,0,ADC_STARTGROUPCONVERSION_ID, ADC_E_WRONG_TRIGG_SRC);\r
1173     returnValue = E_NOT_OK;\r
1174   }\r
1175   else if (!((ADC_IDLE             == AdcConfigPtr->groupConfigPtr[group].status->groupStatus) ||\r
1176              (ADC_STREAM_COMPLETED == AdcConfigPtr->groupConfigPtr[group].status->groupStatus)))\r
1177   {\r
1178     /* Group status not OK, ADC351, ADC428 */\r
1179     Det_ReportError(MODULE_ID_ADC,0,ADC_STARTGROUPCONVERSION_ID, ADC_E_BUSY );\r
1180 \r
1181     //returnValue = E_NOT_OK;\r
1182     returnValue = E_OK;\r
1183   }\r
1184   else\r
1185   {\r
1186     returnValue = E_OK;\r
1187   }\r
1188 #endif\r
1189 \r
1190   return (returnValue);\r
1191 }\r
1192 \r
1193 static Std_ReturnType Adc_CheckStopGroupConversion (Adc_GroupType group)\r
1194 {\r
1195   Std_ReturnType returnValue = E_OK;\r
1196 \r
1197 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1198   if( (ValidateInit(ADC_STOPGROUPCONVERSION_ID) == E_NOT_OK) ||\r
1199       (ValidateGroup(group, ADC_STOPGROUPCONVERSION_ID) == E_NOT_OK))\r
1200   {\r
1201           returnValue = E_NOT_OK;\r
1202   }\r
1203   else if (!(ADC_TRIGG_SRC_SW == AdcConfigPtr->groupConfigPtr[group].triggerSrc))\r
1204   {\r
1205         /* Wrong trig source, ADC164. */\r
1206         Det_ReportError(MODULE_ID_ADC,0,ADC_STOPGROUPCONVERSION_ID, ADC_E_WRONG_TRIGG_SRC);\r
1207         returnValue = E_NOT_OK;\r
1208   }\r
1209   else if (ADC_IDLE == AdcConfigPtr->groupConfigPtr[group].status->groupStatus)\r
1210   {\r
1211         /* Group status not OK, ADC241 */\r
1212         Det_ReportError(MODULE_ID_ADC,0,ADC_STOPGROUPCONVERSION_ID, ADC_E_IDLE );\r
1213         returnValue = E_NOT_OK;\r
1214   }\r
1215   else\r
1216   {\r
1217         returnValue = E_OK;\r
1218   }\r
1219 #endif\r
1220 \r
1221   return (returnValue);\r
1222 }\r
1223 #endif\r
1224 \r
1225 static Std_ReturnType Adc_CheckInit (const Adc_ConfigType *ConfigPtr)\r
1226 {\r
1227   Std_ReturnType returnValue = E_OK;\r
1228 \r
1229 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1230   if (!(ADC_UNINIT == adcState))\r
1231   {\r
1232     /* Oops, already initialised. */\r
1233     Det_ReportError(MODULE_ID_ADC,0,ADC_INIT_ID, ADC_E_ALREADY_INITIALIZED );\r
1234     returnValue = E_NOT_OK;\r
1235   }\r
1236   else if (ConfigPtr == NULL)\r
1237   {\r
1238     /* Wrong config! */\r
1239     Det_ReportError(MODULE_ID_ADC,0,ADC_INIT_ID, ADC_E_PARAM_CONFIG );\r
1240     returnValue = E_NOT_OK;\r
1241   }\r
1242   else\r
1243   {\r
1244     /* Looks good!! */\r
1245     returnValue = E_OK;\r
1246   }\r
1247 #endif\r
1248   return (returnValue);\r
1249 }\r
1250 \r
1251 #if (ADC_DEINIT_API == STD_ON)\r
1252 static Std_ReturnType Adc_CheckDeInit (void)\r
1253 {\r
1254         Std_ReturnType returnValue = E_OK;\r
1255 \r
1256 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1257         if(ValidateInit(ADC_DEINIT_ID) == E_OK)\r
1258         {\r
1259                 for (Adc_GroupType group = ADC_GROUP0; group < AdcConfigPtr->nbrOfGroups; group++)\r
1260                 {\r
1261                         /*  Check ADC is IDLE or COMPLETE*/\r
1262                         if((AdcConfigPtr->groupConfigPtr[group].status->groupStatus != ADC_IDLE) && (AdcConfigPtr->groupConfigPtr[group].status->groupStatus != ADC_STREAM_COMPLETED))\r
1263                         {\r
1264                                 Det_ReportError(MODULE_ID_ADC,0,ADC_DEINIT_ID, ADC_E_BUSY );\r
1265                                 returnValue = E_NOT_OK;\r
1266                         }\r
1267                 }\r
1268         }\r
1269         else\r
1270         {\r
1271                 returnValue = E_NOT_OK;\r
1272         }\r
1273 #endif\r
1274         return (returnValue);\r
1275 }\r
1276 #endif\r
1277 \r
1278 static Std_ReturnType Adc_CheckSetupResultBuffer (Adc_GroupType group)\r
1279 {\r
1280   Std_ReturnType returnValue = E_OK;\r
1281 \r
1282 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1283   if(ValidateGroup(group, ADC_SETUPRESULTBUFFER_ID) == E_NOT_OK)\r
1284   {\r
1285           returnValue = E_NOT_OK;\r
1286   }\r
1287 #endif\r
1288   return (returnValue);\r
1289 }\r
1290 \r
1291 static Std_ReturnType Adc_CheckGetStreamLastPointer (Adc_GroupType group)\r
1292 {\r
1293   Std_ReturnType returnValue = E_OK;\r
1294 \r
1295 #if ( ADC_DEV_ERROR_DETECT == STD_ON )\r
1296   if( (ValidateInit(ADC_GETSTREAMLASTPOINTER_ID) == E_NOT_OK) ||\r
1297           (ValidateGroup(group, ADC_GETSTREAMLASTPOINTER_ID) == E_NOT_OK))\r
1298   {\r
1299           returnValue = E_NOT_OK;\r
1300   }\r
1301   else if(AdcConfigPtr->groupConfigPtr[group].status->groupStatus == ADC_IDLE)\r
1302   { /** @req ADC215 Check ADC is not in IDLE */\r
1303         Det_ReportError(MODULE_ID_ADC,0,ADC_GETSTREAMLASTPOINTER_ID, ADC_E_IDLE );\r
1304         returnValue = E_NOT_OK;\r
1305   }\r
1306 #endif\r
1307   return (returnValue);\r
1308 }\r
1309 \r
1310 \r
1311 \r