arch/ppc/mpc55xx/drivers/Gpt.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 /* ----------------------------[information]----------------------------------*/\r
  17 /*\r
  18  * Author: mahi\r
  19  *\r
  20  * Part of Release:\r
  21  *   3.1.5 (ok, it says 3.1.1 but, thats wrong)\r
  22  *\r
  23  * Description:\r
  24  *   Implements the Gpt module\r
  25  *\r
  26  * Support:\r
  27  *   General                                                      Support\r
  28  *   -------------------------------------------\r
  29  *   GPT_DEV_ERROR_DETECT                                   Y\r
  30  *\r
  31  *\r
  32  *  GptConfigurationOfOptApiServices      Support\r
  33  *   -------------------------------------------\r
  34  *   GPT_DEINIT_API                                                     Y\r
  35  *   GPT_ENABLE_DISABLE_NOTIFICATION_API        Y\r
  36  *   GPT_TIME_ELAPSED_API                                       Y\r
  37  *   GPT_TIME_REMAINING_API                                     Y\r
  38  *   GPT_VERSION_INFO_API                                       Y\r
  39  *   GPT_WAKEUP_FUNCTIONALITY_API                       Y\r
  40  *\r
  41  * Implementation Notes:\r
  42  *\r
  43  * Things left:\r
  44  *   Lots of tagging still to do.\r
  45  */\r
  46 \r
  47 /* ----------------------------[includes]------------------------------------*/\r
  48 \r
  49 #include "Std_Types.h"\r
  50 #include "Gpt.h"\r
  51 #include "Cpu.h"\r
  52 #include <assert.h>\r
  53 #include <string.h>\r
  54 #include "mpc55xx.h"\r
  55 #include "Mcu.h"\r
  56 #include "debug.h"\r
  57 #include "Det.h"\r
  58 #include "Os.h"\r
  59 #include "isr.h"\r
  60 \r
  61 /* ----------------------------[private define]------------------------------*/\r
  62 /* ----------------------------[private macro]-------------------------------*/\r
  63 \r
  64 #if ( GPT_DEV_ERROR_DETECT == STD_ON )\r
  65 #define VALIDATE(_exp,_api,_err ) \\r
  66         if( !(_exp) ) { \\r
  67           Det_ReportError(MODULE_ID_GPT,0,_api,_err); \\r
  68           return; \\r
  69         }\r
  70 \r
  71 #define VALIDATE_W_RV(_exp,_api,_err,_rv ) \\r
  72         if( !(_exp) ) { \\r
  73           Det_ReportError(MODULE_ID_GPT,0,_api,_err); \\r
  74           return (_rv); \\r
  75         }\r
  76 \r
  77 #define VALID_CHANNEL(_ch)              ( Gpt_Global.configured & (1<<(_ch)) )\r
  78 \r
  79 #else\r
  80 #define VALIDATE(_exp,_api,_err )\r
  81 #define VALIDATE_W_RV(_exp,_api,_err,_rv )\r
  82 #endif\r
  83 \r
  84 /* ----------------------------[private typedef]-----------------------------*/\r
  85 /* ----------------------------[private function prototypes]-----------------*/\r
  86 /* ----------------------------[private variables]---------------------------*/\r
  87 /* ----------------------------[private functions]---------------------------*/\r
  88 /* ----------------------------[public functions]----------------------------*/\r
  89 \r
  90 typedef enum {\r
  91         GPT_STATE_STOPPED = 0, GPT_STATE_STARTED,\r
  92 } Gpt_StateType;\r
  93 \r
  94 /**\r
  95  * Type that holds all global data for Gpt\r
  96  */\r
  97 typedef struct {\r
  98         // Set if Gpt_Init() have been called\r
  99         boolean initRun;\r
 100 \r
 101         // Our config\r
 102         const Gpt_ConfigType *config;\r
 103 \r
 104         uint8 wakeupEnabled;\r
 105 \r
 106         // One bit for each channel that is configured.\r
 107         // Used to determine if validity of a channel\r
 108         // 1 - configured\r
 109         // 0 - NOT configured\r
 110         uint32 configured;\r
 111 \r
 112         // Maps the a channel id to a configured channel id\r
 113         uint8 channelMap[GPT_CHANNEL_CNT];\r
 114 \r
 115 } Gpt_GlobalType;\r
 116 \r
 117 /**\r
 118  * Type that holds data that are specific for a channel\r
 119  */\r
 120 typedef struct {\r
 121         Gpt_StateType state;\r
 122 } Gpt_UnitType;\r
 123 \r
 124 Gpt_UnitType Gpt_Unit[GPT_CHANNEL_CNT];\r
 125 \r
 126 // Global config\r
 127 Gpt_GlobalType Gpt_Global;\r
 128 \r
 129 //-------------------------------------------------------------------\r
 130 \r
 131 /*\r
 132  * ISR for a given PIT channel (macro)\r
 133  */\r
 134 #if defined(CFG_MPC560X)\r
 135 #define GPT_ISR( _channel )                                \\r
 136         static void Gpt_Isr_Channel##_channel( void )          \\r
 137         {                                                      \\r
 138         const Gpt_ConfigType *config;                      \\r
 139         int confCh;                                        \\r
 140                                                            \\r
 141         /* Find the config entry for the PIT channel. */   \\r
 142                 confCh = Gpt_Global.channelMap[ _channel ];        \\r
 143                 assert(confCh != GPT_CHANNEL_ILL);                 \\r
 144                 config = &Gpt_Global.config[ confCh ];             \\r
 145                                                            \\r
 146         if( config->GptChannelMode == GPT_MODE_ONESHOT )   \\r
 147         {                                                  \\r
 148             /* Disable the channel. */                     \\r
 149                     PIT.CH[_channel].TCTRL.B.TEN = 0;              \\r
 150                     Gpt_Unit[_channel].state = GPT_STATE_STOPPED;  \\r
 151         }                                                  \\r
 152         config->GptNotification();                         \\r
 153                                                            \\r
 154         /* Clear interrupt. */                             \\r
 155         PIT.CH[_channel].TFLG.B.TIF = 1;                   \\r
 156         }\r
 157 #else\r
 158 #define GPT_ISR( _channel )                            \\r
 159   static void Gpt_Isr_Channel##_channel( void )        \\r
 160   {                                                    \\r
 161     const Gpt_ConfigType *config;                      \\r
 162     int confCh;                                        \\r
 163                                                        \\r
 164     /* Find the config entry for the PIT channel. */   \\r
 165     confCh = Gpt_Global.channelMap[ _channel ];        \\r
 166     assert(confCh != GPT_CHANNEL_ILL);                 \\r
 167     config = &Gpt_Global.config[ confCh ];             \\r
 168                                                        \\r
 169     if( config->GptChannelMode == GPT_MODE_ONESHOT )   \\r
 170     {                                                  \\r
 171       /* Disable the channel. */                       \\r
 172       PIT.EN.R &= ~( 1 << _channel );                  \\r
 173                                                        \\r
 174       Gpt_Unit[_channel].state = GPT_STATE_STOPPED;    \\r
 175     }                                                  \\r
 176     config->GptNotification();                         \\r
 177                                                        \\r
 178     /* Clear interrupt. */                             \\r
 179     PIT.FLG.R = ( 1 << _channel );                     \\r
 180   }\r
 181 #endif\r
 182 \r
 183 #define STR__(x)        #x\r
 184 #define XSTR__(x) STR__(x)\r
 185 \r
 186 /*\r
 187  * Create instances of the ISR for each PIT channel.\r
 188  */\r
 189 GPT_ISR( 0 )\r
 190 GPT_ISR( 1 )\r
 191 GPT_ISR( 2 )\r
 192 GPT_ISR( 3 )\r
 193 #if !defined(CFG_MPC5606S)\r
 194 GPT_ISR( 4 )\r
 195 GPT_ISR( 5 )\r
 196 #if !defined(CFG_MPC5604B)\r
 197 GPT_ISR( 6 )\r
 198 GPT_ISR( 7 )\r
 199 GPT_ISR( 8 )\r
 200 #endif\r
 201 #endif\r
 202 \r
 203 #if defined(CFG_MPC560X)\r
 204         #if defined(CFG_MPC5606S)\r
 205                 #define GPT_CHANNEL_PIT_LAST GPT_CHANNEL_PIT_3\r
 206         #elif defined(CFG_MPC5604B)\r
 207                 #define GPT_CHANNEL_PIT_LAST GPT_CHANNEL_PIT_5\r
 208         #endif\r
 209 #endif\r
 210 \r
 211 //-------------------------------------------------------------------\r
 212 \r
 213 void Gpt_Init(const Gpt_ConfigType *config) {\r
 214         /** @req 3.1.5/GPT280 */\r
 215         /** @req 3.1.5/GPT006 */\r
 216         /** !req 3.1.5/GPT272 Post build not supported */\r
 217         /** @req 3.1.5/GPT107 The module is disabled */\r
 218         /** @req 3.1.5/GPT068 Global registers must be touched */\r
 219         /** @req 3.1.5/GPT205 */\r
 220         /** !req 3.1.5/GPT294 Post build not supported */\r
 221         /** !req 3.1.5/GPT309 TODO: Check*/\r
 222 \r
 223         uint32_t i = 0;\r
 224         const Gpt_ConfigType *cfg;\r
 225         /** @req 3.1.5/GPT307 */\r
 226         VALIDATE( (Gpt_Global.initRun == STD_OFF), GPT_INIT_SERVICE_ID, GPT_E_ALREADY_INITIALIZED );\r
 227 #if defined(GPT_VARIANT_PB)\r
 228         VALIDATE( (config != NULL ), GPT_INIT_SERVICE_ID, GPT_E_PARAM_CONFIG );\r
 229 #elif   defined(GPT_VARIANT_PC)\r
 230         // We don't support GPT_VARIANT_PC\r
 231         assert(0);\r
 232 #endif\r
 233         Gpt_ChannelType ch;\r
 234 \r
 235         for (i = 0; i < GPT_CHANNEL_CNT; i++) {\r
 236                 Gpt_Global.channelMap[i] = GPT_CHANNEL_ILL;\r
 237         }\r
 238 \r
 239         i = 0;\r
 240         cfg = config;\r
 241         while (cfg->GptChannelId != GPT_CHANNEL_ILL) {\r
 242                 ch = cfg->GptChannelId;\r
 243 \r
 244                 // Assign the configuration channel used later..\r
 245                 Gpt_Global.channelMap[cfg->GptChannelId] = i;\r
 246                 Gpt_Global.configured |= (1 << ch);\r
 247 \r
 248 #if defined(CFG_MPC560X)\r
 249                 if (ch <= GPT_CHANNEL_PIT_LAST)\r
 250                 {\r
 251                         if (cfg->GptNotification != NULL)\r
 252                         {\r
 253                                 switch( ch )\r
 254                                 {\r
 255                                         case 0: ISR_INSTALL_ISR2( "Gpt_0", Gpt_Isr_Channel0, PIT_INT0, 2, 0 ); break;\r
 256                                         case 1: ISR_INSTALL_ISR2( "Gpt_1", Gpt_Isr_Channel1, PIT_INT1, 2, 0 ); break;\r
 257                                         case 2: ISR_INSTALL_ISR2( "Gpt_2", Gpt_Isr_Channel2, PIT_INT2, 2, 0 ); break;\r
 258                                         case 3: ISR_INSTALL_ISR2( "Gpt_3", Gpt_Isr_Channel3, PIT_INT3, 2, 0 ); break;\r
 259 #if !defined(CFG_MPC5606S)\r
 260                                         case 4: ISR_INSTALL_ISR2( "Gpt_4", Gpt_Isr_Channel4, PIT_INT4, 2, 0 ); break;\r
 261                                         case 5: ISR_INSTALL_ISR2( "Gpt_5", Gpt_Isr_Channel5, PIT_INT5, 2, 0 ); break;\r
 262 #endif\r
 263                                         default:\r
 264                                         {\r
 265                                                 // Unknown PIT channel.\r
 266                                                 assert( 0 );\r
 267                                                 break;\r
 268                                         }\r
 269                                 }\r
 270                         }\r
 271                 }\r
 272 #else\r
 273                 if (ch <= GPT_CHANNEL_PIT_8) {\r
 274                         if (cfg->GptNotification != NULL) {\r
 275                                 switch (ch) {\r
 276                                 // TODO: What to do with cfg->GptNotificationPriority ?\r
 277                                 case 0:\r
 278                                         ISR_INSTALL_ISR2( "Gpt_0", Gpt_Isr_Channel0, PIT_PITFLG_RTIF, 2, 0 )\r
 279                                         ;\r
 280                                         break;\r
 281                                 case 1:\r
 282                                         ISR_INSTALL_ISR2( "Gpt_1", Gpt_Isr_Channel1, PIT_PITFLG_PIT1, 2, 0 )\r
 283                                         ;\r
 284                                         break;\r
 285                                 case 2:\r
 286                                         ISR_INSTALL_ISR2( "Gpt_2", Gpt_Isr_Channel2, PIT_PITFLG_PIT2, 2, 0 )\r
 287                                         ;\r
 288                                         break;\r
 289                                 case 3:\r
 290                                         ISR_INSTALL_ISR2( "Gpt_3", Gpt_Isr_Channel3, PIT_PITFLG_PIT3, 2, 0 )\r
 291                                         ;\r
 292                                         break;\r
 293                                 case 4:\r
 294                                         ISR_INSTALL_ISR2( "Gpt_4", Gpt_Isr_Channel4, PIT_PITFLG_PIT4, 2, 0 )\r
 295                                         ;\r
 296                                         break;\r
 297                                 case 5:\r
 298                                         ISR_INSTALL_ISR2( "Gpt_5", Gpt_Isr_Channel5, PIT_PITFLG_PIT5, 2, 0 )\r
 299                                         ;\r
 300                                         break;\r
 301                                 case 6:\r
 302                                         ISR_INSTALL_ISR2( "Gpt_6", Gpt_Isr_Channel6, PIT_PITFLG_PIT6, 2, 0 )\r
 303                                         ;\r
 304                                         break;\r
 305                                 case 7:\r
 306                                         ISR_INSTALL_ISR2( "Gpt_7", Gpt_Isr_Channel7, PIT_PITFLG_PIT7, 2, 0 )\r
 307                                         ;\r
 308                                         break;\r
 309                                 case 8:\r
 310                                         ISR_INSTALL_ISR2( "Gpt_8", Gpt_Isr_Channel8, PIT_PITFLG_PIT8, 2, 0 )\r
 311                                         ;\r
 312                                         break;\r
 313                                 default: {\r
 314                                         // Unknown PIT channel.\r
 315                                         assert( 0 );\r
 316                                         break;\r
 317                                 }\r
 318                                 }\r
 319                         }\r
 320                 }\r
 321 #endif\r
 322 \r
 323 #if defined(CFG_MPC560X)\r
 324                 //nothing needed to do\r
 325 #else\r
 326 #endif\r
 327                 cfg++;\r
 328                 i++;\r
 329         }\r
 330 \r
 331         Gpt_Global.config = config;\r
 332 \r
 333         Gpt_Global.initRun = STD_ON;\r
 334 \r
 335 #if defined(CFG_MPC560X)\r
 336         for(i = 0; i <= GPT_CHANNEL_PIT_LAST; i++)\r
 337         {\r
 338                 PIT.CH[i].TCTRL.B.TIE = 0;\r
 339         }\r
 340 \r
 341         PIT.MCR.B.MDIS = 0;\r
 342         PIT.MCR.B.FRZ = 1;\r
 343 #else\r
 344         /* @req 3.1.5|GPT258 */\r
 345         PIT.CTRL.B.MDIS = 0;\r
 346 #endif\r
 347 \r
 348 }\r
 349 \r
 350 //-------------------------------------------------------------------\r
 351 \r
 352 /** @req 3.1.5/GPT194 */\r
 353 #if GPT_DEINIT_API == STD_ON\r
 354 \r
 355 void Gpt_DeInit(void)\r
 356 {\r
 357         /** @req 3.1.5/GPT281 */\r
 358         /** !req 3.1.5/GPT008 TODO: Shouldn't MDIS be set to 1 */\r
 359         /** @req 3.1.5/GPT161 */\r
 360         /** @req 3.1.5/GPT105 */\r
 361         /** @req 3.1.5/GPT162 */\r
 362         /** !req 3.1.5/GPT308 Post build not supported */\r
 363         /** !req 3.1.5/GPT234 It has sideaffects now */\r
 364 \r
 365         Gpt_ChannelType channel;\r
 366 \r
 367         /* @req 3.1.5/GPT220 */\r
 368         VALIDATE( (Gpt_Global.initRun == STD_ON), GPT_DEINIT_SERVICE_ID, GPT_E_UNINIT );\r
 369         for (channel=0; channel<GPT_CHANNEL_CNT; channel++) // Validate that all channels have been stopped\r
 370         {\r
 371                 VALIDATE( (Gpt_Unit[channel].state == GPT_STATE_STOPPED), GPT_DEINIT_SERVICE_ID, GPT_E_BUSY );\r
 372                 Gpt_StopTimer(channel); // Should this be done here?\r
 373         }\r
 374         Gpt_Global.initRun = STD_OFF;\r
 375         Gpt_Global.configured = 0;\r
 376         //_config.config = NULL;\r
 377 }\r
 378 #endif\r
 379 \r
 380 //-------------------------------------------------------------------\r
 381 // period is in "ticks" !!\r
 382 void Gpt_StartTimer(Gpt_ChannelType channel, Gpt_ValueType period_ticks) {\r
 383 #if !defined(CFG_MPC560X)\r
 384         uint32_t tmp;\r
 385 #endif\r
 386         int confCh;\r
 387 \r
 388         VALIDATE( (Gpt_Global.initRun == STD_ON), GPT_STARTTIMER_SERVICE_ID, GPT_E_UNINIT ); VALIDATE( VALID_CHANNEL(channel), GPT_STARTTIMER_SERVICE_ID, GPT_E_PARAM_CHANNEL ); VALIDATE( (Gpt_Unit[channel].state == GPT_STATE_STOPPED), GPT_STARTTIMER_SERVICE_ID, GPT_E_BUSY );\r
 389         // GPT_E_PARAM_VALUE, all have 32-bit so no need to check\r
 390 \r
 391         DEBUG(DEBUG_HIGH, "Gpt_StartTimer ch=%d, period=%d [ticks]\n", channel, period_ticks);\r
 392 \r
 393         confCh = Gpt_Global.channelMap[channel];\r
 394 #if defined(CFG_MPC560X)\r
 395         if (channel <= GPT_CHANNEL_PIT_LAST)\r
 396         {\r
 397                 PIT.CH[channel].LDVAL.R = period_ticks;\r
 398 \r
 399                 // Make sure that no interrupt is pending.\r
 400                 PIT.CH[channel].TFLG.B.TIF = 1;\r
 401                 // Enable timer\r
 402                 PIT.CH[channel].TCTRL.B.TEN = 1;\r
 403         }\r
 404 #else\r
 405         if (channel <= GPT_CHANNEL_PIT_8) {\r
 406                 uint32 *tlval = (uint32 *) &PIT.TLVAL0;\r
 407                 uint32 *tval = (uint32 *) &PIT.TVAL0;\r
 408 \r
 409                 tlval[channel] = period_ticks;\r
 410                 tval[channel] = period_ticks;\r
 411 \r
 412                 // always select interrupt\r
 413                 if (channel != GPT_CHANNEL_RTI) {\r
 414                         PIT.INTSEL.R |= (1 << channel);\r
 415                 }\r
 416 \r
 417                 // Make sure that no interrupt is pending.\r
 418                 PIT.FLG.R = (1 << channel);\r
 419 \r
 420                 // Enable timer\r
 421                 PIT.EN.R |= (1 << channel);\r
 422         } else if (channel == GPT_CHANNEL_DEC) {\r
 423                 // Enable the TB\r
 424                 tmp = get_spr(SPR_HID0);\r
 425                 tmp |= HID0_TBEN;\r
 426                 set_spr(SPR_HID0,tmp);\r
 427 \r
 428                 /* Initialize the Decrementer */\r
 429                 set_spr(SPR_DEC, period_ticks);\r
 430                 set_spr(SPR_DECAR, period_ticks);\r
 431 \r
 432                 if (Gpt_Global.config[confCh].GptChannelMode == GPT_MODE_CONTINUOUS) {\r
 433                         /* Set autoreload */\r
 434                         tmp = get_spr(SPR_TCR);\r
 435                         tmp |= TCR_ARE;\r
 436                         set_spr(SPR_TCR,tmp);\r
 437                 }\r
 438         }\r
 439 #endif\r
 440         if (Gpt_Global.config[confCh].GptNotification != NULL) {\r
 441                 // GPT275\r
 442                 Gpt_EnableNotification(channel);\r
 443         }\r
 444 \r
 445         Gpt_Unit[channel].state = GPT_STATE_STARTED;\r
 446 }\r
 447 \r
 448 void Gpt_StopTimer(Gpt_ChannelType channel) {\r
 449 \r
 450         VALIDATE( (Gpt_Global.initRun == STD_ON), GPT_STOPTIMER_SERVICE_ID, GPT_E_UNINIT ); VALIDATE( VALID_CHANNEL(channel), GPT_STOPTIMER_SERVICE_ID, GPT_E_PARAM_CHANNEL );\r
 451 \r
 452 #if defined(CFG_MPC560X)\r
 453         if (channel <= GPT_CHANNEL_PIT_LAST)\r
 454         {\r
 455                 // Disable timer\r
 456                 PIT.CH[channel].TCTRL.B.TEN = 0;\r
 457         }\r
 458 #else\r
 459         if (channel <= GPT_CHANNEL_PIT_8) {\r
 460                 // Disable timer\r
 461                 PIT.EN.R &= ~(1 << channel);\r
 462         } else if (channel == GPT_CHANNEL_DEC) {\r
 463                 uint32 tb;\r
 464                 tb = get_spr(SPR_HID0);\r
 465                 tb &= ~HID0_TBEN;\r
 466                 set_spr(SPR_HID0,tb);\r
 467         }\r
 468 #endif\r
 469         Gpt_DisableNotification(channel);\r
 470         Gpt_Unit[channel].state = GPT_STATE_STOPPED;\r
 471 }\r
 472 \r
 473 #if ( GPT_TIME_REMAINING_API == STD_ON )\r
 474 \r
 475 Gpt_ValueType Gpt_GetTimeRemaining(Gpt_ChannelType channel)\r
 476 {\r
 477         VALIDATE_W_RV( (Gpt_Global.initRun == STD_ON), GPT_GETTIMEREMAINING_SERVICE_ID, GPT_E_UNINIT, 0 );\r
 478         VALIDATE_W_RV( VALID_CHANNEL(channel),GPT_GETTIMEREMAINING_SERVICE_ID, GPT_E_PARAM_CHANNEL, 0 );\r
 479         VALIDATE_W_RV( (Gpt_Unit[channel].state == GPT_STATE_STARTED), GPT_GETTIMEREMAINING_SERVICE_ID, GPT_E_NOT_STARTED, 0 );\r
 480         Gpt_ValueType remaining;\r
 481 \r
 482 #if defined(CFG_MPC560X)\r
 483         if (channel <= GPT_CHANNEL_PIT_LAST)\r
 484         {\r
 485                 // Time remaining is the time until it hits 0, so just return the current timer value\r
 486                 remaining = PIT.CH[channel].CVAL.R;\r
 487         }\r
 488 #else\r
 489         if (channel <= GPT_CHANNEL_PIT_8)\r
 490         {\r
 491                 uint32 *tval = (uint32 *)&PIT.TVAL0;\r
 492                 // Time remaining is the time until it hits 0, so just return the current timer value\r
 493                 remaining = tval[channel];\r
 494         }\r
 495         else if (channel == GPT_CHANNEL_DEC)\r
 496         {\r
 497                 remaining = get_spr(SPR_DEC);\r
 498         }\r
 499         else\r
 500         {\r
 501                 /* We have written a fault in the fault log. Return 0. */\r
 502                 remaining = 0;\r
 503         }\r
 504 #endif\r
 505 \r
 506         return remaining;\r
 507 }\r
 508 #endif\r
 509 \r
 510 #if ( GPT_TIME_ELAPSED_API == STD_ON )\r
 511 Gpt_ValueType Gpt_GetTimeElapsed(Gpt_ChannelType channel)\r
 512 {\r
 513         Gpt_ValueType timer;\r
 514 \r
 515         VALIDATE_W_RV( (Gpt_Global.initRun == STD_ON), GPT_GETTIMEELAPSED_SERVICE_ID, GPT_E_UNINIT ,0 );\r
 516         VALIDATE_W_RV( VALID_CHANNEL(channel),GPT_GETTIMEELAPSED_SERVICE_ID, GPT_E_PARAM_CHANNEL, 0 );\r
 517         VALIDATE_W_RV( (Gpt_Unit[channel].state == GPT_STATE_STARTED),GPT_GETTIMEELAPSED_SERVICE_ID, GPT_E_NOT_STARTED, 0 );\r
 518 \r
 519         // NOTE!\r
 520         // These little creatures count down\r
 521 \r
 522 #if defined(CFG_MPC560X)\r
 523         if (channel <= GPT_CHANNEL_PIT_LAST)\r
 524         {\r
 525                 uint32 tval = PIT.CH[channel].CVAL.R;\r
 526                 uint32 tlval = PIT.CH[channel].LDVAL.R;\r
 527                 timer = tlval - tval;\r
 528         }\r
 529         else\r
 530         {\r
 531                 timer = 0;\r
 532         }\r
 533 #else\r
 534         if (channel <= GPT_CHANNEL_PIT_8)\r
 535         {\r
 536                 uint32 *tval = (uint32 *)&PIT.TVAL0;\r
 537                 uint32 *tlval = (uint32 *)&PIT.TLVAL0;\r
 538                 timer = tlval[channel] - tval[channel];\r
 539         }\r
 540         else if (channel == GPT_CHANNEL_DEC)\r
 541         {\r
 542                 timer = get_spr(SPR_DECAR) - get_spr(SPR_DEC);\r
 543         }\r
 544         else\r
 545         {\r
 546                 /* We have written a fault in the fault log. Return 0. */\r
 547                 timer = 0;\r
 548         }\r
 549 #endif\r
 550 \r
 551         return (timer);\r
 552 }\r
 553 #endif\r
 554 \r
 555 #if ( GPT_ENABLE_DISABLE_NOTIFICATION_API == STD_ON )\r
 556 void Gpt_EnableNotification(Gpt_ChannelType channel)\r
 557 {\r
 558 \r
 559         VALIDATE( (Gpt_Global.initRun == STD_ON), 0x7, GPT_E_UNINIT );\r
 560         VALIDATE( VALID_CHANNEL(channel),0x7, GPT_E_PARAM_CHANNEL );\r
 561 \r
 562 #if defined(CFG_MPC560X)\r
 563         if (channel <= GPT_CHANNEL_PIT_LAST)\r
 564         {\r
 565                 PIT.CH[channel].TCTRL.B.TIE = 1;\r
 566         }\r
 567 #else\r
 568         if (channel <= GPT_CHANNEL_PIT_8)\r
 569         {\r
 570                 // enable interrupts\r
 571                 PIT.INTEN.R |= ( 1 << channel );\r
 572         }\r
 573         else if (channel == GPT_CHANNEL_DEC)\r
 574         {\r
 575                 uint32 tmp;\r
 576                 tmp = get_spr(SPR_TCR);\r
 577                 tmp |= TCR_DIE;\r
 578                 set_spr(SPR_TCR, tmp );\r
 579         }\r
 580 #endif\r
 581 }\r
 582 \r
 583 void Gpt_DisableNotification(Gpt_ChannelType channel)\r
 584 {\r
 585 \r
 586         VALIDATE( (Gpt_Global.initRun == STD_ON), 0x8, GPT_E_UNINIT );\r
 587         VALIDATE( VALID_CHANNEL(channel),0x8, GPT_E_PARAM_CHANNEL );\r
 588 \r
 589 #if defined(CFG_MPC560X)\r
 590         if (channel <= GPT_CHANNEL_PIT_LAST)\r
 591         {\r
 592                 PIT.CH[channel].TCTRL.B.TIE = 0;\r
 593         }\r
 594 #else\r
 595         if (channel <= GPT_CHANNEL_PIT_8)\r
 596         {\r
 597                 PIT.INTEN.R &= ~( 1 << channel );\r
 598         }\r
 599         else if (channel == GPT_CHANNEL_DEC)\r
 600         {\r
 601                 uint32 tmp;\r
 602                 tmp = get_spr(SPR_TCR);\r
 603                 tmp &= ~TCR_DIE;\r
 604                 set_spr(SPR_TCR, tmp );\r
 605         }\r
 606 #endif\r
 607         return;\r
 608 }\r
 609 \r
 610 #endif\r
 611 \r
 612 #if ( GPT_WAKEUP_FUNCTIONALITY_API == STD_ON )\r
 613 \r
 614 void Gpt_SetMode(Gpt_ModeType mode)\r
 615 {\r
 616         int i;\r
 617 \r
 618         VALIDATE( (Gpt_Global.initRun == STD_ON), GPT_SETMODE_SERVIVCE_ID, GPT_E_UNINIT );\r
 619         VALIDATE( ( mode <= GPT_MODE_SLEEP ), GPT_SETMODE_SERVIVCE_ID, GPT_E_PARAM_MODE );\r
 620 \r
 621 #if defined(CFG_MPC560X)\r
 622         if (mode == GPT_MODE_NORMAL)\r
 623         {\r
 624                 PIT.PITMCR.B.MDIS = 0;\r
 625                 // Do NOT restart channels\r
 626         }\r
 627         else if (mode == GPT_MODE_SLEEP)\r
 628         {\r
 629                 PIT.PITMCR.B.MDIS = 0;\r
 630                 // Disable all but RTI\r
 631                 for (i= 0; i <= GPT_CHANNEL_PIT_3; i++)\r
 632                 {\r
 633                         Gpt_StopTimer(i);\r
 634                 }\r
 635 #else\r
 636                 if (mode == GPT_MODE_NORMAL)\r
 637                 {\r
 638                         PIT.CTRL.B.MDIS = 0;\r
 639                         // Do NOT restart channels\r
 640                 }\r
 641                 else if (mode == GPT_MODE_SLEEP)\r
 642                 {\r
 643 \r
 644                         PIT.CTRL.B.MDIS = 1;\r
 645                         // Disable all but RTI\r
 646                         for (i= 0; i <= GPT_CHANNEL_PIT_8; i++)\r
 647                         {\r
 648                                 Gpt_StopTimer(i);\r
 649                         }\r
 650                 }\r
 651 #endif\r
 652         }\r
 653 \r
 654         void Gpt_DisableWakeup(Gpt_ChannelType channel)\r
 655         {\r
 656                 VALIDATE( (Gpt_Global.initRun == STD_ON), GPT_DISABLEWAKEUP_SERVICE_ID, GPT_E_UNINIT );\r
 657                 VALIDATE( VALID_CHANNEL(channel), GPT_DISABLEWAKEUP_SERVICE_ID, GPT_E_PARAM_CHANNEL );\r
 658                 // Only RTI have system wakeup\r
 659                 if (channel == GPT_CHANNEL_RTI)\r
 660                 {\r
 661                         Gpt_Global.wakeupEnabled = STD_OFF;\r
 662                 }\r
 663                 else\r
 664                 {\r
 665                         // TODO:\r
 666                         //assert(0);\r
 667                 }\r
 668         }\r
 669 \r
 670         void Gpt_EnableWakeup(Gpt_ChannelType channel)\r
 671         {\r
 672                 VALIDATE( (Gpt_Global.initRun == STD_ON), GPT_ENABLEWAKEUP_SERVICE_ID, GPT_E_UNINIT );\r
 673                 VALIDATE( VALID_CHANNEL(channel),GPT_ENABLEWAKEUP_SERVICE_ID, GPT_E_PARAM_CHANNEL );\r
 674                 if (channel == GPT_CHANNEL_RTI)\r
 675                 {\r
 676                         Gpt_Global.wakeupEnabled = STD_ON;\r
 677                 }\r
 678                 else\r
 679                 {\r
 680                         // TODO:\r
 681                         //assert(0);\r
 682                 }\r
 683         }\r
 684 \r
 685         void Gpt_Cbk_CheckWakeup(EcuM_WakeupSourceType wakeupSource)\r
 686         {\r
 687 \r
 688         }\r
 689 \r
 690 #endif\r
 691 \r
 692 void Gpt_Notification_0(void) {\r
 693 #if defined(CFG_MPC560X)\r
 694         SIU.GPDO[66].B.PDO = ~SIU.GPDO[66].B.PDO;\r
 695 #endif\r
 696 }\r
 697 void Gpt_Notification_1(void) {\r
 698 #if defined(CFG_MPC560X)\r
 699         SIU.GPDO[67].B.PDO = ~SIU.GPDO[67].B.PDO;\r
 700 #endif\r
 701 }\r
 702 void Gpt_Notification_2(void) {\r
 703 #if defined(CFG_MPC560X)\r
 704         SIU.GPDO[68].B.PDO = ~SIU.GPDO[68].B.PDO;\r
 705 #endif\r
 706 }\r
 707 void Gpt_Notification_3(void) {\r
 708 #if defined(CFG_MPC560X)\r
 709         SIU.GPDO[69].B.PDO = ~SIU.GPDO[69].B.PDO;\r
 710 #endif\r
 711 }\r
 712 \r