arch/ppc/mpc55xx/drivers/Adc_560x.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 #include "Adc_Internal.h"\r
  29 \r
  30 /* Uncomment and use DMA for 5606 only if you now what you are doing */\r
  31 #define DONT_USE_DMA_IN_ADC_MPC560X\r
  32 \r
  33 /* Are we gonna use Dma? */\r
  34 #if ( 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 /* Function prototypes. */\r
  44 static void Adc_ConfigureADC (const Adc_ConfigType *ConfigPtr);\r
  45 static void Adc_ConfigureADCInterrupts (void);\r
  46 \r
  47 void Adc_GroupConversionComplete (Adc_GroupType group);\r
  48 \r
  49 /* static variable declarations */\r
  50 static Adc_StateType adcState = ADC_UNINIT;\r
  51 static const Adc_ConfigType *AdcConfigPtr;      /* Pointer to configuration structure. */\r
  52 \r
  53 \r
  54 #if (ADC_DEINIT_API == STD_ON)\r
  55 void Adc_DeInit ()\r
  56 {\r
  57   if (E_OK == Adc_CheckDeInit(adcState, AdcConfigPtr))\r
  58   {\r
  59     for(Adc_GroupType group = (Adc_GroupType)ADC_GROUP0; group < AdcConfigPtr->nbrOfGroups; group++)\r
  60     {\r
  61       /* Set group status to idle. */\r
  62       AdcConfigPtr->groupConfigPtr[group].status->groupStatus = ADC_IDLE;\r
  63     }\r
  64 \r
  65     /* Disable DMA transfer*/\r
  66 #ifndef CFG_MPC5604B\r
  67     ADC_0.DMAE.B.DMAEN = 0;\r
  68 #endif\r
  69     /* Power down ADC */\r
  70     ADC_0.MCR.R = 0x0001;\r
  71 \r
  72     /* Disable all interrupt*/\r
  73     ADC_0.IMR.R = 0;\r
  74 \r
  75     /* Clean internal status. */\r
  76     AdcConfigPtr = (Adc_ConfigType *)NULL;\r
  77     adcState = ADC_UNINIT;\r
  78   }\r
  79 }\r
  80 #endif\r
  81 \r
  82 void Adc_Init (const Adc_ConfigType *ConfigPtr)\r
  83 {\r
  84   if (E_OK == Adc_CheckInit(adcState, ConfigPtr))\r
  85   {\r
  86             /* First of all, store the location of the configuration data. */\r
  87             AdcConfigPtr = ConfigPtr;\r
  88 \r
  89             /* Enable ADC. */\r
  90              Adc_ConfigureADC(ConfigPtr);\r
  91 \r
  92              Adc_ConfigureADCInterrupts();\r
  93 \r
  94             /* Move on to INIT state. */\r
  95             adcState = ADC_INIT;\r
  96   }\r
  97 }\r
  98 \r
  99 Std_ReturnType Adc_SetupResultBuffer (Adc_GroupType group, Adc_ValueGroupType *bufferPtr)\r
 100 {\r
 101   Std_ReturnType returnValue = E_NOT_OK;\r
 102 \r
 103   /* Check for development errors. */\r
 104   if (E_OK == Adc_CheckSetupResultBuffer (adcState, AdcConfigPtr, group))\r
 105   {\r
 106     AdcConfigPtr->groupConfigPtr[group].status->resultBufferPtr = bufferPtr;\r
 107     \r
 108     returnValue = E_OK;\r
 109   }\r
 110 \r
 111   return (returnValue);\r
 112 }\r
 113 \r
 114 Adc_StreamNumSampleType Adc_GetStreamLastPointer(Adc_GroupType group, Adc_ValueGroupType** PtrToSamplePtr)\r
 115 {\r
 116         Adc_StreamNumSampleType nofSample = 0;\r
 117         Adc_GroupDefType *groupPtr = (Adc_GroupDefType *)&AdcConfigPtr->groupConfigPtr[group];\r
 118         \r
 119         /** @req ADC216 */\r
 120         /* Check for development errors. */\r
 121         if ( (E_OK == Adc_CheckGetStreamLastPointer (adcState, AdcConfigPtr, group)) &&\r
 122                  (groupPtr->status->groupStatus != ADC_BUSY) )\r
 123         {\r
 124             /* Set resultPtr to application buffer. */\r
 125                 if(groupPtr->status->currSampleCount > 0){\r
 126                         *PtrToSamplePtr = &groupPtr->status->resultBufferPtr[groupPtr->status->currSampleCount-1];\r
 127                 }\r
 128 \r
 129             if ((ADC_CONV_MODE_ONESHOT == groupPtr->conversionMode) &&\r
 130                 (ADC_STREAM_COMPLETED  == groupPtr->status->groupStatus))\r
 131             {\r
 132                         /** @req ADC327. */\r
 133                         groupPtr->status->groupStatus = ADC_IDLE;\r
 134             }\r
 135             else if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 136                      (ADC_ACCESS_MODE_STREAMING == groupPtr->accessMode) &&\r
 137                      (ADC_STREAM_BUFFER_LINEAR == groupPtr->streamBufferMode) &&\r
 138                      (ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus))\r
 139             {\r
 140                         /** @req ADC327. */\r
 141                         groupPtr->status->groupStatus = ADC_IDLE;\r
 142             }\r
 143             else if ( (ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 144                       ((ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus) ||\r
 145                        (ADC_COMPLETED           == groupPtr->status->groupStatus)) )\r
 146             {\r
 147                 /* Restart continous mode, and reset result buffer */\r
 148                 if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 149                     (ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus))\r
 150                 {\r
 151                           /* Start continous conversion again */\r
 152                         Adc_StartGroupConversion(group);\r
 153                 }\r
 154                         /** @req ADC326 */\r
 155                         /** @req ADC328 */\r
 156             }\r
 157             else{/* Keep status. */}\r
 158         }\r
 159         else\r
 160         {\r
 161                 /* Some condition not met */\r
 162                 *PtrToSamplePtr = NULL;\r
 163         }\r
 164 \r
 165         return nofSample;\r
 166 \r
 167 }\r
 168 \r
 169 #if (ADC_READ_GROUP_API == STD_ON)\r
 170 Std_ReturnType Adc_ReadGroup (Adc_GroupType group, Adc_ValueGroupType *dataBufferPtr)\r
 171 {\r
 172   Std_ReturnType returnValue = E_OK;\r
 173   uint8_t channel;\r
 174   Adc_GroupDefType *groupPtr = (Adc_GroupDefType *)&AdcConfigPtr->groupConfigPtr[group];\r
 175 \r
 176   if (E_OK == Adc_CheckReadGroup (adcState, AdcConfigPtr, group))\r
 177   {\r
 178     /* Copy the result to application buffer. */\r
 179     for (channel = 0; channel < groupPtr->numberOfChannels; channel++)\r
 180         {\r
 181                 if(groupPtr->status->currSampleCount > 0){\r
 182                         dataBufferPtr[channel] = (&(groupPtr->status->resultBufferPtr[groupPtr->status->currSampleCount-1]))[channel];\r
 183                 }else{\r
 184                         dataBufferPtr[channel] = groupPtr->status->resultBufferPtr[channel];\r
 185                 }\r
 186         }\r
 187 \r
 188     if ((ADC_CONV_MODE_ONESHOT == groupPtr->conversionMode) &&\r
 189         (ADC_STREAM_COMPLETED  == groupPtr->status->groupStatus))\r
 190     {\r
 191                 /** @req ADC330. */\r
 192                 groupPtr->status->groupStatus = ADC_IDLE;\r
 193     }\r
 194     else if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 195              (ADC_STREAM_BUFFER_LINEAR == groupPtr->streamBufferMode) &&\r
 196              (ADC_ACCESS_MODE_STREAMING == groupPtr->accessMode) &&\r
 197              (ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus))\r
 198     {\r
 199                 /** @req ADC330. */\r
 200                 groupPtr->status->groupStatus = ADC_IDLE;\r
 201     }\r
 202     else if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 203              ((ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus) ||\r
 204               (ADC_COMPLETED           == groupPtr->status->groupStatus)))\r
 205     {\r
 206         /** @req ADC329 */\r
 207       /* Restart continous mode, and reset result buffer */\r
 208       if ((ADC_CONV_MODE_CONTINOUS == groupPtr->conversionMode) &&\r
 209           (ADC_STREAM_COMPLETED    == groupPtr->status->groupStatus))\r
 210       {\r
 211                   /* Start continous conversion again */\r
 212         Adc_StartGroupConversion(group);\r
 213       }\r
 214       /** @req ADC329 */\r
 215       /** @req ADC331 */\r
 216     }\r
 217     else{/* Keep status. */}\r
 218   }\r
 219   else\r
 220   {\r
 221     /* An error have been raised from Adc_CheckReadGroup(). */\r
 222     returnValue = E_NOT_OK;\r
 223   }\r
 224 \r
 225   return (returnValue);\r
 226 }\r
 227 #endif\r
 228 \r
 229 void Adc_GroupConversionComplete (Adc_GroupType group)\r
 230 {\r
 231         Adc_GroupDefType *adcGroup = (Adc_GroupDefType *)&AdcConfigPtr->groupConfigPtr[group];\r
 232 \r
 233   if(ADC_ACCESS_MODE_SINGLE == adcGroup->accessMode )\r
 234   {\r
 235           adcGroup->status->groupStatus = ADC_STREAM_COMPLETED;\r
 236 \r
 237     /* Disable trigger normal conversions for ADC0 */\r
 238     ADC_0.MCR.B.NSTART=0;\r
 239 \r
 240           /* Call notification if enabled. */\r
 241         #if (ADC_GRP_NOTIF_CAPABILITY == STD_ON)\r
 242           if (adcGroup->status->notifictionEnable && adcGroup->groupCallback != NULL)\r
 243           {\r
 244                   adcGroup->groupCallback();\r
 245           }\r
 246         #endif\r
 247   }\r
 248   else\r
 249   {\r
 250         if(ADC_STREAM_BUFFER_LINEAR == adcGroup->streamBufferMode)\r
 251         {\r
 252                 adcGroup->status->currSampleCount++;\r
 253                 if(adcGroup->status->currSampleCount < adcGroup->streamNumSamples)\r
 254                 {\r
 255                   adcGroup->status->currResultBufPtr += adcGroup->numberOfChannels;\r
 256                   adcGroup->status->groupStatus = ADC_COMPLETED;\r
 257 \r
 258 #if defined (ADC_USES_DMA)\r
 259                   /* Increase current result buffer ptr */\r
 260                 Dma_ConfigureDestinationAddress((uint32_t)adcGroup->status->currResultBufPtr, adcGroup->dmaResultChannel);\r
 261 #endif\r
 262 \r
 263                 ADC_0.IMR.B.MSKECH = 1;\r
 264             ADC_0.MCR.B.NSTART=1;\r
 265                 }\r
 266                 else\r
 267                 {\r
 268                   /* All sample completed. */\r
 269                   adcGroup->status->groupStatus = ADC_STREAM_COMPLETED;\r
 270 \r
 271       /* Disable trigger normal conversions for ADC0 */\r
 272       ADC_0.MCR.B.NSTART=0;\r
 273 \r
 274                   /* Call notification if enabled. */\r
 275                 #if (ADC_GRP_NOTIF_CAPABILITY == STD_ON)\r
 276                   if (adcGroup->status->notifictionEnable && adcGroup->groupCallback != NULL){\r
 277                         adcGroup->groupCallback();\r
 278                   }\r
 279                 #endif\r
 280                 }\r
 281         }\r
 282         else if(ADC_STREAM_BUFFER_CIRCULAR == adcGroup->streamBufferMode)\r
 283         {\r
 284                 adcGroup->status->currSampleCount++;\r
 285                 if(adcGroup->status->currSampleCount < adcGroup->streamNumSamples)\r
 286                 {\r
 287                         adcGroup->status->currResultBufPtr += adcGroup->numberOfChannels;\r
 288 #if defined (ADC_USES_DMA)\r
 289                         /* Increase current result buffer ptr */\r
 290                         Dma_ConfigureDestinationAddress((uint32_t)adcGroup->status->currResultBufPtr, adcGroup->dmaResultChannel);\r
 291 #endif\r
 292                         adcGroup->status->groupStatus = ADC_COMPLETED;\r
 293 \r
 294                         ADC_0.IMR.B.MSKECH = 1;\r
 295                     ADC_0.MCR.B.NSTART=1;\r
 296                 }\r
 297                 else\r
 298                 {\r
 299                   /* Sample completed. */\r
 300 \r
 301                   /* Disable trigger normal conversions for ADC*/\r
 302                   ADC_0.MCR.B.NSTART=0;\r
 303 \r
 304                   adcGroup->status->groupStatus = ADC_STREAM_COMPLETED;\r
 305                   /* Call notification if enabled. */\r
 306                 #if (ADC_GRP_NOTIF_CAPABILITY == STD_ON)\r
 307                   if (adcGroup->status->notifictionEnable && adcGroup->groupCallback != NULL)\r
 308                   {\r
 309                           adcGroup->groupCallback();\r
 310                   }\r
 311                 #endif\r
 312                 }\r
 313         }\r
 314         else\r
 315         {\r
 316                 //nothing to do.\r
 317         }\r
 318   }\r
 319 }\r
 320 void Adc_Group0ConversionComplete (void)\r
 321 {\r
 322         /* Clear ECH Flag and disable interruput */\r
 323         ADC_0.ISR.B.ECH = 1;\r
 324         ADC_0.IMR.B.MSKECH = 0;\r
 325 \r
 326         // Check which group is busy, only one is allowed to be busy at a time in a hw unit\r
 327         for (int group = 0; group < ADC_NBR_OF_GROUPS; group++)\r
 328         {\r
 329           if((AdcConfigPtr->groupConfigPtr[group].status->groupStatus == ADC_BUSY) ||\r
 330        (AdcConfigPtr->groupConfigPtr[group].status->groupStatus == ADC_COMPLETED))\r
 331           {\r
 332 #if !defined (ADC_USES_DMA)\r
 333                 /* Copy to result buffer */\r
 334                 for(uint8 index=0; index < AdcConfigPtr->groupConfigPtr[group].numberOfChannels; index++)\r
 335                 {\r
 336 #if defined(CFG_MPC5606S)\r
 337                         AdcConfigPtr->groupConfigPtr[group].status->currResultBufPtr[index] = ADC_0.CDR[32+AdcConfigPtr->groupConfigPtr[group].channelList[index]].B.CDATA;\r
 338 #else\r
 339                         AdcConfigPtr->groupConfigPtr[group].status->currResultBufPtr[index] = ADC_0.CDR[AdcConfigPtr->groupConfigPtr[group].channelList[index]].B.CDATA;\r
 340 #endif\r
 341                 }\r
 342 #endif\r
 343 \r
 344             Adc_GroupConversionComplete((Adc_GroupType)group);\r
 345                 break;\r
 346           }\r
 347         }\r
 348 }\r
 349 \r
 350 void Adc_WatchdogError (void){\r
 351 }\r
 352 void Adc_ADCError (void){\r
 353 }\r
 354 \r
 355 static void  Adc_ConfigureADC (const Adc_ConfigType *ConfigPtr)\r
 356 {\r
 357   /* Set ADC CLOCK */\r
 358   ADC_0.MCR.B.ADCLKSEL = ConfigPtr->hwConfigPtr->adcPrescale;\r
 359 \r
 360   ADC_0.DSDR.B.DSD = 254;\r
 361 \r
 362   /* Power on ADC */\r
 363   ADC_0.MCR.B.PWDN = 0;\r
 364 \r
 365 #if defined(ADC_USES_DMA)\r
 366   /* Enable DMA. */\r
 367   ADC_0.DMAE.B.DMAEN = 1;\r
 368 #endif\r
 369 }\r
 370 \r
 371 void Adc_ConfigureADCInterrupts (void)\r
 372 {\r
 373         ISR_INSTALL_ISR2(  "Adc_Err", Adc_ADCError, ADC_ER_INT,     2, 0 );\r
 374         ISR_INSTALL_ISR2(  "Adc_Grp", Adc_Group0ConversionComplete, ADC_EOC_INT,     2, 0 );\r
 375         ISR_INSTALL_ISR2(  "Adc_Wdg", Adc_WatchdogError, ADC_WD_INT,     2, 0 );\r
 376 }\r
 377 \r
 378 #if (ADC_ENABLE_START_STOP_GROUP_API == STD_ON)\r
 379 void Adc_StartGroupConversion (Adc_GroupType group)\r
 380 {\r
 381         Adc_GroupDefType *groupPtr = (Adc_GroupDefType *)&AdcConfigPtr->groupConfigPtr[group];\r
 382 \r
 383         /* Run development error check. */\r
 384         if (E_OK == Adc_CheckStartGroupConversion (adcState, AdcConfigPtr, group))\r
 385         {\r
 386                 /* Disable trigger normal conversions for ADC0 */\r
 387                 ADC_0.MCR.B.NSTART = 0;\r
 388 \r
 389                 /* Set group state to BUSY. */\r
 390                 groupPtr->status->groupStatus = ADC_BUSY;\r
 391 \r
 392                 groupPtr->status->currSampleCount = 0;\r
 393                 groupPtr->status->currResultBufPtr = groupPtr->status->resultBufferPtr; /* Set current result buffer */\r
 394 \r
 395 #if defined(ADC_USES_DMA)\r
 396                 Dma_ConfigureChannel ((Dma_TcdType *)groupPtr->groupDMAResults, groupPtr->dmaResultChannel);\r
 397                 Dma_ConfigureDestinationAddress ((uint32_t)groupPtr->status->currResultBufPtr, groupPtr->dmaResultChannel);\r
 398 #endif\r
 399                 /* Always use single shot in streaming mode */\r
 400                 if( groupPtr->accessMode == ADC_ACCESS_MODE_STREAMING)\r
 401                 {\r
 402                         /* Set conversion mode. */\r
 403                         ADC_0.MCR.B.MODE = ADC_CONV_MODE_ONESHOT;\r
 404                 }\r
 405                 else\r
 406                 {\r
 407                         /* Set conversion mode. */\r
 408                         ADC_0.MCR.B.MODE = groupPtr->conversionMode;\r
 409                 }\r
 410 \r
 411                 /* Enable Overwrite*/\r
 412                 ADC_0.MCR.B.OWREN = 1;\r
 413 \r
 414                 /* Set Conversion Time. */\r
 415 #if defined(CFG_MPC5606S)\r
 416                 uint32 groupChannelIdMask = 0;\r
 417 \r
 418                 ADC_0.CTR[1].B.INPLATCH = groupPtr->adcChannelConvTime.INPLATCH;\r
 419                 ADC_0.CTR[1].B.INPCMP = groupPtr->adcChannelConvTime.INPCMP;\r
 420                 ADC_0.CTR[1].B.INPSAMP = groupPtr->adcChannelConvTime.INPSAMP;\r
 421 \r
 422                 for(uint8 i =0; i < groupPtr->numberOfChannels; i++)\r
 423                 {\r
 424                         groupChannelIdMask |= (1 << groupPtr->channelList[i]);\r
 425                 }\r
 426 \r
 427 #if defined(ADC_USES_DMA)\r
 428                 ADC_0.DMAE.R = 0x01;\r
 429                 /* Enable DMA Transfer */\r
 430                 ADC_0.DMAR[1].R = groupChannelIdMask;\r
 431                 Dma_StartChannel(DMA_ADC_GROUP0_RESULT_CHANNEL);        /* Enable EDMA channel for ADC */\r
 432 #endif\r
 433 \r
 434                 /* Enable Normal conversion */\r
 435                 ADC_0.NCMR[1].R = groupChannelIdMask;\r
 436 \r
 437                 /* Enable Channel Interrupt */\r
 438                 ADC_0.CIMR[1].R = groupChannelIdMask;\r
 439 \r
 440 #else\r
 441                 uint32 groupChannelIdMask[3] = {0,0,0};\r
 442 \r
 443                 ADC_0.CTR[0].B.INPLATCH = groupPtr->adcChannelConvTime.INPLATCH;\r
 444                 ADC_0.CTR[0].B.INPCMP = groupPtr->adcChannelConvTime.INPCMP;\r
 445                 ADC_0.CTR[0].B.INPSAMP = groupPtr->adcChannelConvTime.INPSAMP;\r
 446                 ADC_0.CTR[1].B.INPLATCH = groupPtr->adcChannelConvTime.INPLATCH;\r
 447                 ADC_0.CTR[1].B.INPCMP = groupPtr->adcChannelConvTime.INPCMP;\r
 448                 ADC_0.CTR[1].B.INPSAMP = groupPtr->adcChannelConvTime.INPSAMP;\r
 449                 ADC_0.CTR[2].B.INPLATCH = groupPtr->adcChannelConvTime.INPLATCH;\r
 450                 ADC_0.CTR[2].B.INPCMP = groupPtr->adcChannelConvTime.INPCMP;\r
 451                 ADC_0.CTR[2].B.INPSAMP = groupPtr->adcChannelConvTime.INPSAMP;\r
 452 \r
 453                 for(uint8 i =0; i < groupPtr->numberOfChannels; i++)\r
 454                 {\r
 455                         if(groupPtr->channelList[i] <= 15){\r
 456                                 groupChannelIdMask[0] |= (1 << groupPtr->channelList[i]);\r
 457                         }else if((groupPtr->channelList[i] >= 32) && (groupPtr->channelList[i] <=47)){\r
 458                                 groupChannelIdMask[1] |= (1 << (groupPtr->channelList[i] - 32));\r
 459                         }else if((groupPtr->channelList[i] >= 64) && (groupPtr->channelList[i] <=95)){\r
 460                                 groupChannelIdMask[2] |= (1 << (groupPtr->channelList[i] - 64));\r
 461                         }\r
 462                 }\r
 463 \r
 464                 /* Enable Normal conversion */\r
 465                 ADC_0.NCMR[0].R = groupChannelIdMask[0];\r
 466                 ADC_0.NCMR[1].R = groupChannelIdMask[1];\r
 467                 ADC_0.NCMR[2].R = groupChannelIdMask[2];\r
 468 \r
 469                 /* Enable Channel Interrupt */\r
 470                 ADC_0.CIMR[0].R = groupChannelIdMask[0];\r
 471                 ADC_0.CIMR[1].R = groupChannelIdMask[1];\r
 472                 ADC_0.CIMR[2].R = groupChannelIdMask[2];\r
 473 #endif\r
 474                 /* Clear interrupts */\r
 475                 ADC_0.ISR.B.ECH = 1;\r
 476                 /* Enable ECH interrupt */\r
 477                 ADC_0.IMR.B.MSKECH = 1;\r
 478 \r
 479                 /* Trigger normal conversions for ADC0 */\r
 480                 ADC_0.MCR.B.NSTART = 1;\r
 481         }\r
 482         else\r
 483         {\r
 484         /* Error have been set within Adc_CheckStartGroupConversion(). */\r
 485         }\r
 486 }\r
 487 \r
 488 void Adc_StopGroupConversion (Adc_GroupType group)\r
 489 {\r
 490   if (E_OK == Adc_CheckStopGroupConversion (adcState, AdcConfigPtr, group))\r
 491   {\r
 492         /* Disable trigger normal conversions for ADC0 */\r
 493         ADC_0.MCR.B.NSTART = 0;\r
 494 \r
 495         /* Set group state to IDLE. */\r
 496         AdcConfigPtr->groupConfigPtr[group].status->groupStatus = ADC_IDLE;\r
 497 \r
 498         /* Disable group notification if enabled. */\r
 499     if(1 == AdcConfigPtr->groupConfigPtr[group].status->notifictionEnable){\r
 500         Adc_DisableGroupNotification (group);\r
 501     }\r
 502   }\r
 503   else\r
 504   {\r
 505         /* Error have been set within Adc_CheckStartGroupConversion(). */\r
 506   }\r
 507 }\r
 508 #endif  /* endof #if (ADC_ENABLE_START_STOP_GROUP_API == STD_ON) */\r
 509 \r
 510 #if (ADC_GRP_NOTIF_CAPABILITY == STD_ON)\r
 511 void Adc_EnableGroupNotification (Adc_GroupType group)\r
 512 {\r
 513         Adc_EnableInternalGroupNotification(adcState, AdcConfigPtr, group);\r
 514 }\r
 515 \r
 516 void Adc_DisableGroupNotification (Adc_GroupType group)\r
 517 {\r
 518         Adc_InternalDisableGroupNotification(adcState, AdcConfigPtr, group);\r
 519 }\r
 520 #endif\r
 521 \r
 522 Adc_StatusType Adc_GetGroupStatus (Adc_GroupType group)\r
 523 {\r
 524         return Adc_InternalGetGroupStatus(adcState, AdcConfigPtr, group);\r
 525 }\r
 526 \r