arch/ppc/mpc55xx/drivers/Mcu.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 /* ----------------------------[includes]------------------------------------*/\r
  18 #include <assert.h>\r
  19 #include <string.h>\r
  20 #include "Std_Types.h"\r
  21 #include "Mcu.h"\r
  22 #include "Det.h"\r
  23 #if defined(USE_DEM)\r
  24 #include "Dem.h"\r
  25 #endif\r
  26 #include "mpc55xx.h"\r
  27 #include "Cpu.h"\r
  28 #include "Ramlog.h"\r
  29 #include "Os.h"\r
  30 #include "irq.h"\r
  31 \r
  32 /* ----------------------------[private define]------------------------------*/\r
  33 //#define USE_TRACE 1\r
  34 //#define USE_LDEBUG_PRINTF 1\r
  35 #include "debug.h"\r
  36 \r
  37 #define SYSCLOCK_SELECT_PLL     0x2\r
  38 \r
  39 /* ----------------------------[private macro]-------------------------------*/\r
  40 \r
  41 #if defined(CFG_MPC5567)\r
  42 #define CALC_SYSTEM_CLOCK(_extal,_emfd,_eprediv,_erfd)  \\r
  43             ( (_extal) * ((_emfd)+4) / (((_eprediv)+1)*(1<<(_erfd))) )\r
  44 #else\r
  45 #define CALC_SYSTEM_CLOCK(_extal,_emfd,_eprediv,_erfd)  \\r
  46             ( (_extal) * ((_emfd)+16) / (((_eprediv)+1)*((_erfd)+1)) )\r
  47 #endif\r
  48 \r
  49 /* Development error macros. */\r
  50 #if ( MCU_DEV_ERROR_DETECT == STD_ON )\r
  51 #define VALIDATE(_exp,_api,_err ) \\r
  52         if( !(_exp) ) { \\r
  53           Det_ReportError(MODULE_ID_MCU,0,_api,_err); \\r
  54           return; \\r
  55         }\r
  56 \r
  57 #define VALIDATE_W_RV(_exp,_api,_err,_rv ) \\r
  58         if( !(_exp) ) { \\r
  59           Det_ReportError(MODULE_ID_MCU,0,_api,_err); \\r
  60           return (_rv); \\r
  61         }\r
  62 #else\r
  63 #define VALIDATE(_exp,_api,_err )\r
  64 #define VALIDATE_W_RV(_exp,_api,_err,_rv )\r
  65 #endif\r
  66 \r
  67 \r
  68 /* ----------------------------[private typedef]-----------------------------*/\r
  69 typedef void (*vfunc_t)();\r
  70 \r
  71 typedef struct {\r
  72         uint32 lossOfLockCnt;\r
  73         uint32 lossOfClockCnt;\r
  74 } Mcu_Stats;\r
  75 \r
  76 /**\r
  77  * Type that holds all global data for Mcu\r
  78  */\r
  79 typedef struct\r
  80 {\r
  81   // Set if Mcu_Init() have been called\r
  82   boolean initRun;\r
  83 \r
  84   // Our config\r
  85   const Mcu_ConfigType *config;\r
  86 \r
  87   Mcu_ClockType clockSetting;\r
  88 \r
  89   Mcu_Stats stats;\r
  90 \r
  91 } Mcu_GlobalType;\r
  92 \r
  93 \r
  94 /* ----------------------------[private function prototypes]-----------------*/\r
  95 static void Mcu_ConfigureFlash(void);\r
  96 /* ----------------------------[private variables]---------------------------*/\r
  97 \r
  98 // Global config\r
  99 Mcu_GlobalType Mcu_Global =\r
 100 {\r
 101                 .initRun = 0,\r
 102                 .config = &McuConfigData[0],\r
 103 };\r
 104 \r
 105 /* ----------------------------[private functions]---------------------------*/\r
 106 /* ----------------------------[public functions]----------------------------*/\r
 107 \r
 108 \r
 109 /**\r
 110  * ISR wh
 111  */\r
 112 static void Mcu_LossOfLock( void  ) {\r
 113 #if defined(USE_DEM)\r
 114         Dem_ReportErrorStatus(MCU_E_CLOCK_FAILURE, DEM_EVENT_STATUS_FAILED);\r
 115 #endif\r
 116 \r
 117         Mcu_Global.stats.lossOfLockCnt++;\r
 118         // Clear interrupt\r
 119         FMPLL.SYNSR.B.LOLF = 1;\r
 120 \r
 121 }\r
 122 \r
 123 /**\r
 124  *
 125  */\r
 126 static void Mcu_LossOfClock( void  ) {\r
 127 \r
 128         /* Should report MCU_E_CLOCK_FAILURE with DEM here */\r
 129 \r
 130         Mcu_Global.stats.lossOfClockCnt++;\r
 131         // Clear interrupt\r
 132         FMPLL.SYNSR.B.LOCF = 1;\r
 133 }\r
 134 \r
 135 \r
 136 #define SPR_PIR 286\r
 137 #define SPR_PVR 287\r
 138 \r
 139 #define CORE_PVR_E200Z1         0x81440000UL\r
 140 #define CORE_PVR_E200Z0         0x81710000UL\r
 141 #define CORE_PVR_E200Z3         0x81120000UL\r
 142 #define CORE_PVR_E200Z6         0x81170000UL\r
 143 \r
 144 \r
 145 typedef struct {\r
 146   char *name;\r
 147   uint32 pvr;\r
 148 } core_info_t;\r
 149 \r
 150 typedef struct {\r
 151   char *name;\r
 152   uint32 pvr;\r
 153 } cpu_info_t;\r
 154 \r
 155 cpu_info_t cpu_info_list[] =\r
 156 {\r
 157 #if defined(CFG_MPC5516)\r
 158     {\r
 159     .name = "MPC5516",\r
 160     .pvr = CORE_PVR_E200Z1,\r
 161     },\r
 162     {\r
 163     .name = "MPC5516",\r
 164     .pvr = CORE_PVR_E200Z0,\r
 165     },\r
 166 #elif defined(CFG_MPC5567)\r
 167     {\r
 168         .name = "MPC5567",\r
 169         .pvr = CORE_PVR_E200Z6,\r
 170     }\r
 171 #elif defined(CFG_MPC5633)\r
 172     {\r
 173     .name = "MPC563X",\r
 174     .pvr = CORE_PVR_E200Z3,\r
 175     },\r
 176 #endif\r
 177 };\r
 178 \r
 179 core_info_t core_info_list[] = {\r
 180 #if defined(CFG_MPC5516)\r
 181         {\r
 182     .name = "CORE_E200Z1",\r
 183     .pvr = CORE_PVR_E200Z1,\r
 184     },\r
 185     {\r
 186     .name = "CORE_E200Z1",\r
 187     .pvr = CORE_PVR_E200Z1,\r
 188     },\r
 189 #elif defined(CFG_MPC5567)\r
 190     {\r
 191         .name = "CORE_E200Z6",\r
 192         .pvr = CORE_PVR_E200Z6,\r
 193     }\r
 194 #elif defined(CFG_MPC5633)\r
 195     {\r
 196     .name = "CORE_E200Z3",\r
 197     .pvr = CORE_PVR_E200Z3,\r
 198     },\r
 199 #endif\r
 200 };\r
 201 \r
 202 // TODO: move\r
 203 #if !defined(ARRAY_SIZE)\r
 204 #define ARRAY_SIZE(_x)  (sizeof(_x)/sizeof((_x)[0]))\r
 205 #endif\r
 206 \r
 207 static cpu_info_t *Mcu_IdentifyCpu(uint32 pvr)\r
 208 {\r
 209   int i;\r
 210   for (i = 0; i < ARRAY_SIZE(cpu_info_list); i++) {\r
 211     if (cpu_info_list[i].pvr == pvr) {\r
 212       return &cpu_info_list[i];\r
 213     }\r
 214   }\r
 215 \r
 216   return NULL;\r
 217 }\r
 218 \r
 219 static core_info_t *Mcu_IdentifyCore(uint32 pvr)\r
 220 {\r
 221   int i;\r
 222   for (i = 0; i < ARRAY_SIZE(core_info_list); i++) {\r
 223     if (core_info_list[i].pvr == pvr) {\r
 224       return &core_info_list[i];\r
 225     }\r
 226   }\r
 227 \r
 228   return NULL;\r
 229 }\r
 230 \r
 231 \r
 232 static uint32 Mcu_CheckCpu( void ) {\r
 233 \r
 234   uint32 pvr;\r
 235   uint32 pir;\r
 236   cpu_info_t *cpuType;\r
 237   core_info_t *coreType;\r
 238 \r
 239   // We have to registers to read here, PIR and PVR\r
 240 \r
 241   pir = get_spr(SPR_PIR);\r
 242   pvr = get_spr(SPR_PVR);\r
 243 \r
 244   cpuType = Mcu_IdentifyCpu(pvr);\r
 245   coreType = Mcu_IdentifyCore(pvr);\r
 246 \r
 247   if( (cpuType == NULL) || (coreType == NULL) ) {\r
 248     // Just hang\r
 249     while(1);\r
 250   }\r
 251 \r
 252   //DEBUG(DEBUG_HIGH,"/drivers/mcu: Cpu:  %s( 0x%08x )\n",cpuType->name,pvr);\r
 253   //DEBUG(DEBUG_HIGH,"/drivers/mcu: Core: %s( 0x%08x )\n",coreType->name,pvr);\r
 254 \r
 255   return 0;\r
 256 }\r
 257 \r
 258 \r
 259 //-------------------------------------------------------------------\r
 260 \r
 261 void Mcu_Init(const Mcu_ConfigType *configPtr) {\r
 262         IRQ_DECL_ISR1( PLL_SYNSR_LOLF,  CPU_CORE0, 10, Mcu_LossOfLock  );\r
 263         IRQ_DECL_ISR1( PLL_SYNSR_LOCF,  CPU_CORE0, 10, Mcu_LossOfClock );\r
 264 \r
 265         VALIDATE( ( NULL != configPtr ), MCU_INIT_SERVICE_ID, MCU_E_PARAM_CONFIG );\r
 266 \r
 267         if (!SIMULATOR()) {\r
 268                 Mcu_CheckCpu();\r
 269         }\r
 270 \r
 271         memset(&Mcu_Global.stats, 0, sizeof(Mcu_Global.stats));\r
 272 \r
 273         //\r
 274         // Setup memories\r
 275         //\r
 276         Mcu_ConfigureFlash();\r
 277 \r
 278         Mcu_Global.config = configPtr;\r
 279         Mcu_Global.initRun = 1;\r
 280 \r
 281         if (Mcu_Global.config->McuClockSrcFailureNotification == TRUE) {\r
 282                 // Enable loss of lock interrupt\r
 283 \r
 284                 Irq_Attach( &IRQ_NAME(PLL_SYNSR_LOLF) );\r
 285 //              Irq_AttachIsr1(Mcu_LossOfLock, NULL, PLL_SYNSR_LOLF, 10);\r
 286 #if defined(CFG_MPC5516)\r
 287                 FMPLL.ESYNCR2.B.LOLIRQ = 1;\r
 288 #elif defined(CFG_MPC5554) || defined(CFG_MPC5567)\r
 289                 FMPLL.SYNCR.B.LOLIRQ = 1;\r
 290 #endif\r
 291 \r
 292                 Irq_Attach( &IRQ_NAME(PLL_SYNSR_LOLF));\r
 293 //              Irq_AttachIsr1(Mcu_LossOfClock, NULL, PLL_SYNSR_LOCF, 10);\r
 294 #if defined(CFG_MPC5516)\r
 295                 FMPLL.ESYNCR2.B.LOCIRQ = 1;\r
 296 #elif defined(CFG_MPC5554) || defined(CFG_MPC5567)\r
 297                 FMPLL.SYNCR.B.LOCIRQ = 1;\r
 298 #endif\r
 299         }\r
 300 }\r
 301 //-------------------------------------------------------------------\r
 302 \r
 303 void Mcu_DeInit()\r
 304 {\r
 305   Mcu_Global.initRun = FALSE; // Very simple Deinit. Should we do more?\r
 306 }\r
 307 \r
 308 //-------------------------------------------------------------------\r
 309 Std_ReturnType Mcu_InitRamSection(const Mcu_RamSectionType RamSection)\r
 310 {\r
 311   VALIDATE_W_RV( ( 1 == Mcu_Global.initRun ), MCU_INITRAMSECTION_SERVICE_ID, MCU_E_UNINIT, E_NOT_OK );\r
 312   VALIDATE_W_RV( ( RamSection <= Mcu_Global.config->McuRamSectors ), MCU_INITRAMSECTION_SERVICE_ID, MCU_E_PARAM_RAMSECTION, E_NOT_OK );\r
 313 \r
 314   /* NOT SUPPORTED, reason: no support for external RAM */\r
 315 \r
 316   return E_OK;\r
 317 }\r
 318 \r
 319 \r
 320 \r
 321 //-------------------------------------------------------------------\r
 322 \r
 323 Std_ReturnType Mcu_InitClock(const Mcu_ClockType ClockSetting)\r
 324 {\r
 325   Mcu_ClockSettingConfigType *clockSettingsPtr;\r
 326   VALIDATE_W_RV( ( 1 == Mcu_Global.initRun ), MCU_INITCLOCK_SERVICE_ID, MCU_E_UNINIT, E_NOT_OK );\r
 327   VALIDATE_W_RV( ( ClockSetting < Mcu_Global.config->McuClockSettings ), MCU_INITCLOCK_SERVICE_ID, MCU_E_PARAM_CLOCK, E_NOT_OK );\r
 328 \r
 329   Mcu_Global.clockSetting = ClockSetting;\r
 330   clockSettingsPtr = &Mcu_Global.config->McuClockSettingConfig[Mcu_Global.clockSetting];\r
 331 \r
 332 \r
 333   // TODO: find out if the 5554 really works like the 5516 here\r
 334   // All three (16, 54, 67) used to run the same code here though, so i'm sticking it with 5516\r
 335 #if defined(CFG_MPC5516) || defined(CFG_MPC5554)\r
 336   /* 5516clock info:\r
 337    * Fsys - System frequency ( CPU + all periperals? )\r
 338    *\r
 339    *  Fsys = EXTAL_FREQ *(  (emfd+16) / ( (eprediv+1) * ( erfd+1 )) ) )\r
 340    */\r
 341   // Check ranges...\r
 342   assert((clockSettingsPtr->Pll2>=32) && (clockSettingsPtr->Pll2<=132));\r
 343   assert( (clockSettingsPtr->Pll1 != 6) &&\r
 344           (clockSettingsPtr->Pll1 != 8) &&\r
 345           (clockSettingsPtr->Pll1 < 10) );\r
 346   assert( clockSettingsPtr->Pll3 & 1); // Must be odd\r
 347 #elif defined(CFG_MPC5567)\r
 348   /* 5567 clock info:\r
 349    *  Fsys = EXTAL_FREQ *(  (emfd+4) / ( (eprediv+1) * ( 2^erfd )) ) )\r
 350    */\r
 351   // Check ranges...\r
 352   assert(clockSettingsPtr->Pll2 < 16);\r
 353   assert(clockSettingsPtr->Pll1 <= 4);\r
 354   assert(clockSettingsPtr->Pll3 < 8);\r
 355 #endif\r
 356 \r
 357 \r
 358 #if defined(USE_LDEBUG_PRINTF)\r
 359   {\r
 360     uint32    extal = Mcu_Global.config->McuClockSettingConfig[Mcu_Global.clockSetting].McuClockReferencePointFrequency;\r
 361     uint32    f_sys;\r
 362 \r
 363     f_sys = CALC_SYSTEM_CLOCK( extal,\r
 364         clockSettingsPtr->Pll2,\r
 365         clockSettingsPtr->Pll1,\r
 366         clockSettingsPtr->Pll3 );\r
 367 \r
 368     //DEBUG(DEBUG_HIGH,"/drivers/mcu: F_sys will be:%08d Hz\n",f_sys);\r
 369   }\r
 370 #endif\r
 371 \r
 372 #if defined(CFG_MPC5516)\r
 373   // External crystal PLL mode.\r
 374   FMPLL.ESYNCR1.B.CLKCFG = 7; //TODO: Hur ställa detta för 5567?\r
 375 \r
 376   // Write pll parameters.\r
 377   FMPLL.ESYNCR1.B.EPREDIV = clockSettingsPtr->Pll1;\r
 378   FMPLL.ESYNCR1.B.EMFD    = clockSettingsPtr->Pll2;\r
 379   FMPLL.ESYNCR2.B.ERFD    = clockSettingsPtr->Pll3;\r
 380 \r
 381   // Connect SYSCLK to FMPLL\r
 382   SIU.SYSCLK.B.SYSCLKSEL = SYSCLOCK_SELECT_PLL;\r
 383 #elif defined(CFG_MPC5554) || defined(CFG_MPC5567)\r
 384   // Partially following the steps in MPC5567 RM..\r
 385   FMPLL.SYNCR.B.DEPTH   = 0;\r
 386   FMPLL.SYNCR.B.LOLRE   = 0;\r
 387   FMPLL.SYNCR.B.LOLIRQ  = 0;\r
 388 \r
 389   FMPLL.SYNCR.B.PREDIV  = clockSettingsPtr->Pll1;\r
 390   FMPLL.SYNCR.B.MFD             = clockSettingsPtr->Pll2;\r
 391   FMPLL.SYNCR.B.RFD     = clockSettingsPtr->Pll3;\r
 392 \r
 393         // Wait for PLL to sync.\r
 394   while (Mcu_GetPllStatus() != MCU_PLL_LOCKED)\r
 395     ;\r
 396 \r
 397   FMPLL.SYNCR.B.LOLIRQ  = 1;\r
 398 #endif\r
 399 \r
 400   return E_OK;\r
 401 }\r
 402 \r
 403 //-------------------------------------------------------------------\r
 404 \r
 405 void Mcu_DistributePllClock(void)\r
 406 {\r
 407   VALIDATE( ( 1 == Mcu_Global.initRun ), MCU_DISTRIBUTEPLLCLOCK_SERVICE_ID, MCU_E_UNINIT );\r
 408   VALIDATE( ( FMPLL.SYNSR.B.LOCK == 1 ), MCU_DISTRIBUTEPLLCLOCK_SERVICE_ID, MCU_E_PLL_NOT_LOCKED );\r
 409 \r
 410   /* NOT IMPLEMENTED due to pointless function on this hardware */\r
 411 \r
 412 }\r
 413 \r
 414 //-------------------------------------------------------------------\r
 415 \r
 416 Mcu_PllStatusType Mcu_GetPllStatus(void)\r
 417 {\r
 418   VALIDATE_W_RV( ( 1 == Mcu_Global.initRun ), MCU_GETPLLSTATUS_SERVICE_ID, MCU_E_UNINIT, MCU_PLL_STATUS_UNDEFINED );\r
 419   Mcu_PllStatusType rv;\r
 420 \r
 421   if( !SIMULATOR() )\r
 422   {\r
 423     if ( !FMPLL.SYNSR.B.LOCK )\r
 424     {\r
 425       rv = MCU_PLL_UNLOCKED;\r
 426     } else\r
 427     {\r
 428       rv = MCU_PLL_LOCKED;\r
 429     }\r
 430   }\r
 431   else\r
 432   {\r
 433     /* We are running on instruction set simulator. PLL is then always in sync... */\r
 434     rv = MCU_PLL_LOCKED;\r
 435   }\r
 436 \r
 437   return rv;\r
 438 }\r
 439 \r
 440 //-------------------------------------------------------------------\r
 441 \r
 442 Mcu_ResetType Mcu_GetResetReason(void)\r
 443 {\r
 444         Mcu_ResetType rv;\r
 445 \r
 446   VALIDATE_W_RV( ( 1 == Mcu_Global.initRun ), MCU_GETRESETREASON_SERVICE_ID, MCU_E_UNINIT, MCU_RESET_UNDEFINED );\r
 447 \r
 448   if( SIU.RSR.B.SSRS ) {\r
 449         rv = MCU_SW_RESET;\r
 450   } else if( SIU.RSR.B.WDRS ) {\r
 451         rv = MCU_WATCHDOG_RESET;\r
 452   } else if( SIU.RSR.B.PORS || SIU.RSR.B.ERS ) {\r
 453         rv = MCU_POWER_ON_RESET;\r
 454   } else {\r
 455         rv = MCU_RESET_UNDEFINED;\r
 456   }\r
 457 \r
 458   return rv;\r
 459 }\r
 460 \r
 461 //-------------------------------------------------------------------\r
 462 \r
 463 Mcu_RawResetType Mcu_GetResetRawValue(void)\r
 464 {\r
 465   VALIDATE_W_RV( ( 1 == Mcu_Global.initRun ), MCU_GETRESETREASON_SERVICE_ID, MCU_E_UNINIT, MCU_GETRESETRAWVALUE_UNINIT_RV );\r
 466 \r
 467   if( !Mcu_Global.initRun ) {\r
 468         return MCU_GETRESETRAWVALUE_UNINIT_RV;\r
 469   }\r
 470 \r
 471   return SIU.RSR.R;\r
 472 }\r
 473 \r
 474 //-------------------------------------------------------------------\r
 475 \r
 476 #if ( MCU_PERFORM_RESET_API == STD_ON )\r
 477 void Mcu_PerformReset(void)\r
 478 {\r
 479   VALIDATE( ( 1 == Mcu_Global.initRun ), MCU_PERFORMRESET_SERVICE_ID, MCU_E_UNINIT );\r
 480 \r
 481   // Reset\r
 482         SIU.SRCR.B.SSR = 1;\r
 483 \r
 484 }\r
 485 #endif\r
 486 \r
 487 //-------------------------------------------------------------------\r
 488 \r
 489 void Mcu_SetMode(const Mcu_ModeType McuMode)\r
 490 {\r
 491   VALIDATE( ( 1 == Mcu_Global.initRun ), MCU_SETMODE_SERVICE_ID, MCU_E_UNINIT );\r
 492  // VALIDATE( ( McuMode <= Mcu_Global.config->McuNumberOfMcuModes ), MCU_SETMODE_SERVICE_ID, MCU_E_PARAM_MODE );\r
 493   (void) McuMode;\r
 494 \r
 495   /* NOT SUPPORTED */\r
 496 }\r
 497 \r
 498 //-------------------------------------------------------------------\r
 499 \r
 500 /**\r
 501  * Get the system clock in Hz. It calculates the clock from the\r
 502  * different register settings in HW.\r
 503  */\r
 504 uint32_t McuE_GetSystemClock(void)\r
 505 {\r
 506   /*\r
 507    * System clock calculation\r
 508    *\r
 509    * 5516 -  f_sys = extal * (emfd+16) / ( (eprediv+1) * ( erfd+1 ));\r
 510    * 5567 -  f_sys = extal * (emfd+4) / ( (eprediv+1) * ( 2^erfd ));\r
 511    * 563x -  We run in legacy mode = 5567\r
 512    */\r
 513 #if defined(CFG_MPC5516)\r
 514   uint32_t eprediv = FMPLL.ESYNCR1.B.EPREDIV;\r
 515   uint32_t emfd = FMPLL.ESYNCR1.B.EMFD;\r
 516   uint32_t erfd = FMPLL.ESYNCR2.B.ERFD;\r
 517 #elif defined(CFG_MPC5554) || defined(CFG_MPC5567) || defined(CFG_MPC5633)\r
 518   uint32_t eprediv = FMPLL.SYNCR.B.PREDIV;\r
 519   uint32_t emfd = FMPLL.SYNCR.B.MFD;\r
 520   uint32_t erfd = FMPLL.SYNCR.B.RFD;\r
 521 #endif\r
 522   uint32_t f_sys;\r
 523   uint32  extal = Mcu_Global.config->McuClockSettingConfig[Mcu_Global.clockSetting].McuClockReferencePointFrequency;\r
 524 \r
 525   f_sys =  CALC_SYSTEM_CLOCK(extal,emfd,eprediv,erfd);\r
 526 \r
 527   return f_sys;\r
 528 }\r
 529 \r
 530 imask_t McuE_EnterCriticalSection()\r
 531 {\r
 532   uint32_t msr = get_msr();\r
 533   Irq_Disable();\r
 534   return msr;\r
 535 }\r
 536 \r
 537 void McuE_ExitCriticalSection(uint32_t old_state)\r
 538 {\r
 539   set_msr(old_state);\r
 540 }\r
 541 \r
 542 /**\r
 543  * Get the peripheral clock in Hz for a specific device\r
 544  *
 545  * @param type
 546  * @return
 547  */\r
 548 uint32_t McuE_GetPeripheralClock(McuE_PeriperalClock_t type)\r
 549 {\r
 550 #if defined(CFG_MPC5567)\r
 551         // No peripheral dividers on 5567.\r
 552         return McuE_GetSystemClock();\r
 553 #else\r
 554         uint32_t sysClock = McuE_GetSystemClock();\r
 555         vuint32_t prescaler;\r
 556 \r
 557 \r
 558   // See table 3.1, section 3.4.5 Peripheral Clock dividers\r
 559         switch (type)\r
 560         {\r
 561         case PERIPHERAL_CLOCK_FLEXCAN_A:\r
 562         case PERIPHERAL_CLOCK_DSPI_A:\r
 563 #if defined(CFG_MPC5516)\r
 564                 prescaler = SIU.SYSCLK.B.LPCLKDIV0;\r
 565                 break;\r
 566 #endif\r
 567 \r
 568         case PERIPHERAL_CLOCK_PIT:\r
 569         case PERIPHERAL_CLOCK_ESCI_A:\r
 570         case PERIPHERAL_CLOCK_IIC_A:\r
 571 #if defined(CFG_MPC5516)\r
 572         prescaler = SIU.SYSCLK.B.LPCLKDIV1;\r
 573                 break;\r
 574 #endif\r
 575 \r
 576         case PERIPHERAL_CLOCK_FLEXCAN_B:\r
 577         case PERIPHERAL_CLOCK_FLEXCAN_C:\r
 578         case PERIPHERAL_CLOCK_FLEXCAN_D:\r
 579         case PERIPHERAL_CLOCK_FLEXCAN_E:\r
 580         case PERIPHERAL_CLOCK_FLEXCAN_F:\r
 581 #if defined(CFG_MPC5516)\r
 582                 prescaler = SIU.SYSCLK.B.LPCLKDIV2;\r
 583                 break;\r
 584 #endif\r
 585 \r
 586         case PERIPHERAL_CLOCK_DSPI_B:\r
 587         case PERIPHERAL_CLOCK_DSPI_C:\r
 588         case PERIPHERAL_CLOCK_DSPI_D:\r
 589 #if defined(CFG_MPC5516)\r
 590                 prescaler = SIU.SYSCLK.B.LPCLKDIV3;\r
 591                 break;\r
 592 #endif\r
 593 \r
 594         case PERIPHERAL_CLOCK_ESCI_B:\r
 595         case PERIPHERAL_CLOCK_ESCI_C:\r
 596         case PERIPHERAL_CLOCK_ESCI_D:\r
 597         case PERIPHERAL_CLOCK_ESCI_E:\r
 598         case PERIPHERAL_CLOCK_ESCI_F:\r
 599         case PERIPHERAL_CLOCK_ESCI_G:\r
 600         case PERIPHERAL_CLOCK_ESCI_H:\r
 601 #if defined(CFG_MPC5516)\r
 602           prescaler = SIU.SYSCLK.B.LPCLKDIV4;\r
 603           break;\r
 604 #endif\r
 605 \r
 606         case PERIPHERAL_CLOCK_EMIOS:\r
 607 #if defined(CFG_MPC5516)\r
 608           prescaler = SIU.SYSCLK.B.LPCLKDIV5;\r
 609           break;\r
 610 #endif\r
 611 \r
 612         case PERIPHERAL_CLOCK_MLB:\r
 613 #if defined(CFG_MPC5516)\r
 614           prescaler = SIU.SYSCLK.B.LPCLKDIV6;\r
 615           break;\r
 616 #endif\r
 617 \r
 618         default:\r
 619                 assert(0);\r
 620                 break;\r
 621         }\r
 622 \r
 623         return sysClock/(1<<prescaler);\r
 624 #endif\r
 625 }\r
 626 \r
 627 \r
 628 /**\r
 629  * Function to setup the internal flash for optimal performance\r
 630  */\r
 631 \r
 632 static void Mcu_ConfigureFlash(void)\r
 633 {\r
 634   /* These flash settings increases the CPU performance of 7 times compared\r
 635    to reset default settings!! */\r
 636 \r
 637 #if defined(CFG_MPC5516)\r
 638   /* Disable pipelined reads when flash options are changed. */\r
 639   FLASH.MCR.B.PRD = 1;\r
 640 \r
 641   /* Enable master prefetch for e200z1 and eDMA. */\r
 642   FLASH.PFCRP0.B.M0PFE = 1;\r
 643   FLASH.PFCRP0.B.M2PFE = 1;\r
 644 \r
 645   /* Address pipelining control. Must be set to the same value as RWSC. */\r
 646   FLASH.PFCRP0.B.APC = 2;\r
 647   FLASH.PFCRP0.B.RWSC = 2;\r
 648 \r
 649   /* Write wait states. */\r
 650   FLASH.PFCRP0.B.WWSC = 1;\r
 651 \r
 652   /* Enable data prefetch. */\r
 653   FLASH.PFCRP0.B.DPFEN = 1;\r
 654 \r
 655   /* Enable instruction prefetch. */\r
 656   FLASH.PFCRP0.B.IPFEN = 1;\r
 657 \r
 658   /* Prefetch algorithm. */\r
 659   /* TODO: Ask Freescale about this option. */\r
 660   FLASH.PFCRP0.B.PFLIM = 2;\r
 661 \r
 662   /* Enable line read buffers. */\r
 663   FLASH.PFCRP0.B.BFEN = 1;\r
 664 \r
 665   /* Enable pipelined reads again. */\r
 666   FLASH.MCR.B.PRD = 0;\r
 667 #elif defined(CFG_MPC5554) || defined(CFG_MPC5567)\r
 668   //TODO: Lägg till flash för mpc5554 &67\r
 669 #endif\r
 670 }\r
 671 \r
 672 void McuE_EnableInterrupts(void)\r
 673 {\r
 674   Irq_Enable();\r
 675 }\r
 676 \r
 677 void McuE_DisableInterrupts(void)\r
 678 {\r
 679   Irq_Disable();\r
 680 }\r