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