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