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