Changeset d79a27be in rtems


Ignore:
Timestamp:
Aug 21, 2008, 2:57:19 PM (11 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.9, master
Children:
d9be8024
Parents:
2a517327
Message:

2008-08-21 Sebastian Huber <sebastian.huber@…>

  • startup/cpuinit.h: Uses now powerpc-utility.h. Changed invalid usage of a boolean type to a proper integer type in calc_dbat_regvals(). Througout code formatting.
Location:
c/src/lib/libbsp/powerpc/gen83xx
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/powerpc/gen83xx/ChangeLog

    r2a517327 rd79a27be  
     12008-08-21      Sebastian Huber <sebastian.huber@embedded-brains.de>
     2
     3        * startup/cpuinit.h: Uses now powerpc-utility.h.  Changed invalid usage
     4        of a boolean type to a proper integer type in calc_dbat_regvals().
     5        Througout code formatting.
     6
    172008-08-20      Sebastian Huber <sebastian.huber@embedded-brains.de>
    28
  • c/src/lib/libbsp/powerpc/gen83xx/startup/cpuinit.c

    r2a517327 rd79a27be  
    7171/***********************************************************************/
    7272
     73#include <stdbool.h>
     74#include <string.h>
     75
     76#include <libcpu/powerpc-utility.h>
     77#include <libcpu/mmu.h>
     78
     79#include <mpc83xx/mpc83xx.h>
     80
    7381#include <bsp.h>
    74 #include <rtems/powerpc/registers.h>
    75 #include <mpc83xx/mpc83xx.h>
    76 
    77 #include <libcpu/mmu.h>
    78 #include <libcpu/spr.h>
    79 #include <string.h>
    80 
    81 #define USE_IMMU
    82 
    83 /* Macros for HID0 access */
    84 #define SET_HID0(r)   __asm__ volatile ("mtspr 0x3F0,%0\n" ::"r"(r))
    85 #define GET_HID0(r)   __asm__ volatile ("mfspr %0,0x3F0\n" :"=r"(r))
    86 
    87 #define DBAT_MTSPR(val,name) __MTSPR(val,name);
    88 #define SET_DBAT(n,uv,lv) {DBAT_MTSPR(lv,DBAT##n##L);DBAT_MTSPR(uv,DBAT##n##U);}
    89 #if defined(USE_IMMU )
    90 #define IBAT_MTSPR(val,name) __MTSPR(val,name);
    91 #define SET_IBAT(n,uv,lv) {IBAT_MTSPR(lv,IBAT##n##L);IBAT_MTSPR(uv,IBAT##n##U);}
    92 #endif
    93 
    94 static void calc_dbat_regvals(BAT *bat_ptr,
    95                        uint32_t base_addr,
    96                        uint32_t size,
    97                        boolean flg_w,
    98                        boolean flg_i,
    99                        boolean flg_m,
    100                        boolean flg_g,
    101                        boolean flg_bpp)
     82
     83#define SET_DBAT( n, uv, lv) \
     84  do { \
     85    PPC_SET_SPECIAL_PURPOSE_REGISTER( DBAT##n##L, lv); \
     86    PPC_SET_SPECIAL_PURPOSE_REGISTER( DBAT##n##U, uv); \
     87  } while (0)
     88
     89#define SET_IBAT( n, uv, lv) \
     90  do { \
     91    PPC_SET_SPECIAL_PURPOSE_REGISTER( IBAT##n##L, lv); \
     92    PPC_SET_SPECIAL_PURPOSE_REGISTER( IBAT##n##U, uv); \
     93  } while (0)
     94
     95static void calc_dbat_regvals(
     96  BAT *bat_ptr,
     97  uint32_t base_addr,
     98  uint32_t size,
     99  bool flg_w,
     100  bool flg_i,
     101  bool flg_m,
     102  bool flg_g,
     103  uint32_t flg_bpp
     104)
    102105{
    103   uint32_t block_mask;
    104   uint32_t end_addr;
    105 
    106   /*
    107    * determine block mask, that overlaps the whole block
    108    */
    109   end_addr = base_addr+size-1;
    110   block_mask = 0xffffffff;
     106  uint32_t block_mask = 0xffffffff;
     107  uint32_t end_addr = base_addr + size - 1;
     108
     109  /* Determine block mask, that overlaps the whole block */
    111110  while ((end_addr & block_mask) != (base_addr & block_mask)) {
    112111    block_mask <<= 1;
    113112  }
    114113 
    115   bat_ptr->batu.bepi  = base_addr  >> (32-15);
    116   bat_ptr->batu.bl    = ~(block_mask >> (28-11));
    117   bat_ptr->batu.vs    = 1;
    118   bat_ptr->batu.vp    = 1;
    119  
    120   bat_ptr->batl.brpn  = base_addr  >> (32-15);
    121   bat_ptr->batl.w  = flg_w;
    122   bat_ptr->batl.i  = flg_i;
    123   bat_ptr->batl.m  = flg_m;
    124   bat_ptr->batl.g  = flg_g;
    125   bat_ptr->batl.pp = flg_bpp;
     114  bat_ptr->batu.bepi = base_addr >> (32 - 15);
     115  bat_ptr->batu.bl   = ~(block_mask >> (28 - 11));
     116  bat_ptr->batu.vs   = 1;
     117  bat_ptr->batu.vp   = 1;
     118 
     119  bat_ptr->batl.brpn = base_addr  >> (32 - 15);
     120  bat_ptr->batl.w    = flg_w;
     121  bat_ptr->batl.i    = flg_i;
     122  bat_ptr->batl.m    = flg_m;
     123  bat_ptr->batl.g    = flg_g;
     124  bat_ptr->batl.pp   = flg_bpp;
    126125}
    127126
    128 static void clear_mmu_regs(void)
     127static void clear_mmu_regs( void)
    129128{
    130129  uint32_t i;
    131   /*
    132    * clear segment registers
    133    */
     130
     131  /* Clear segment registers */
    134132  for (i = 0;i < 16;i++) {
    135     asm volatile(" mtsrin       %0, %1\n"::"r" (i * 0x1000),"r"(i<<(31-3)));
     133    asm volatile( "mtsrin %0, %1\n" : : "r" (i * 0x1000), "r" (i << (31 - 3)));
    136134  }
    137   /*
    138    * clear TLBs
    139    */
     135 
     136  /* Clear TLBs */
    140137  for (i = 0;i < 32;i++) {
    141     asm volatile(" tlbie        %0\n"::"r" (i << (31-19)));
     138    asm volatile( "tlbie %0\n" : : "r" (i << (31 - 19)));
    142139  }
    143140}
    144141
    145 void cpu_init(void)
     142void cpu_init( void)
    146143{
    147   register unsigned long reg;
    148   BAT dbat,ibat;
    149 
     144  BAT dbat, ibat;
     145  uint32_t msr;
     146
     147  /* Clear MMU and segment registers */
     148  clear_mmu_regs();
     149
     150  /* Clear caches */
     151  PPC_CLEAR_SPECIAL_PURPOSE_REGISTER_BITS( HID0, HID0_ILOCK | HID0_DLOCK);
     152  PPC_SET_SPECIAL_PURPOSE_REGISTER_BITS( HID0, HID0_ICFI | HID0_DCI);
     153  PPC_CLEAR_SPECIAL_PURPOSE_REGISTER_BITS( HID0, HID0_ICFI | HID0_DCI);
     154 
    150155  /*
    151    * clear MMU/Segment registers
     156   * Set up IBAT registers in MMU
    152157   */
    153   clear_mmu_regs();
     158
     159  memset(&ibat, 0, sizeof( ibat));
     160  SET_IBAT( 2, ibat.batu, ibat.batl);
     161  SET_IBAT( 3, ibat.batu, ibat.batl);
     162  SET_IBAT( 4, ibat.batu, ibat.batl);
     163  SET_IBAT( 5, ibat.batu, ibat.batl);
     164  SET_IBAT( 6, ibat.batu, ibat.batl);
     165  SET_IBAT( 7, ibat.batu, ibat.batl);
     166
     167  calc_dbat_regvals(
     168    &ibat,
     169    #ifdef HAS_UBOOT
     170      mpc83xx_uboot_board_info.bi_memstart,
     171      mpc83xx_uboot_board_info.bi_memsize,
     172    #else /* HAS_UBOOT */
     173      (uint32_t) bsp_ram_start,
     174      (uint32_t) bsp_ram_size,
     175    #endif /* HAS_UBOOT */
     176    false,
     177    false,
     178    false,
     179    false,
     180    BPP_RX
     181  );
     182  SET_IBAT( 0, ibat.batu, ibat.batl);
     183
     184  calc_dbat_regvals(
     185    &ibat,
     186    #ifdef HAS_UBOOT
     187      mpc83xx_uboot_board_info.bi_flashstart,
     188      mpc83xx_uboot_board_info.bi_flashsize,
     189    #else /* HAS_UBOOT */
     190      (uint32_t) bsp_rom_start,
     191      (uint32_t) bsp_rom_size,
     192    #endif /* HAS_UBOOT */
     193    false,
     194    false,
     195    false,
     196    false,
     197    BPP_RX
     198  );
     199  SET_IBAT( 1, ibat.batu, ibat.batl);
     200
    154201  /*
    155    * clear caches
     202   * Set up DBAT registers in MMU
    156203   */
    157   GET_HID0(reg);
    158   reg = (reg & ~(HID0_ILOCK | HID0_DLOCK)) | HID0_ICFI | HID0_DCI;
    159   SET_HID0(reg);
    160   reg &= ~(HID0_ICFI | HID0_DCI);
    161   SET_HID0(reg);
    162  
    163   /*
    164    * set up IBAT registers in MMU
    165    */
    166   memset(&ibat,0,sizeof(ibat));
    167   SET_IBAT(2,ibat.batu,ibat.batl);
    168   SET_IBAT(3,ibat.batu,ibat.batl);
    169   SET_IBAT(4,ibat.batu,ibat.batl);
    170   SET_IBAT(5,ibat.batu,ibat.batl);
    171   SET_IBAT(6,ibat.batu,ibat.batl);
    172   SET_IBAT(7,ibat.batu,ibat.batl);
    173 #ifdef HAS_UBOOT
    174   calc_dbat_regvals(&ibat,mpc83xx_uboot_board_info.bi_memstart,mpc83xx_uboot_board_info.bi_memsize,0,0,0,0,BPP_RX);
    175 #else /* HAS_UBOOT */
    176   calc_dbat_regvals(&ibat,(uint32_t) bsp_ram_start,(uint32_t) bsp_ram_size,0,0,0,0,BPP_RX);
    177 #endif /* HAS_UBOOT */
    178 
    179   SET_IBAT(0,ibat.batu,ibat.batl);
    180 
    181 #ifdef HAS_UBOOT
    182   calc_dbat_regvals(&ibat,mpc83xx_uboot_board_info.bi_flashstart,mpc83xx_uboot_board_info.bi_flashsize,0,0,0,0,BPP_RX);
    183 #else /* HAS_UBOOT */
    184   calc_dbat_regvals(&ibat,(uint32_t) bsp_rom_start,(uint32_t) bsp_rom_size,0,0,0,0,BPP_RX);
    185 #endif /* HAS_UBOOT */
    186 
    187   SET_IBAT(1,ibat.batu,ibat.batl);
    188 
    189   /*
    190    * set up DBAT registers in MMU
    191    */
    192   memset(&dbat,0,sizeof(dbat));
    193   SET_DBAT(3,dbat.batu,dbat.batl);
    194   SET_DBAT(4,dbat.batu,dbat.batl);
    195   SET_DBAT(5,dbat.batu,dbat.batl);
    196   SET_DBAT(6,dbat.batu,dbat.batl);
    197   SET_DBAT(7,dbat.batu,dbat.batl);
    198 
    199 #ifdef HAS_UBOOT
    200   calc_dbat_regvals(&dbat,mpc83xx_uboot_board_info.bi_memstart,mpc83xx_uboot_board_info.bi_memsize,0,0,0,0,BPP_RW);
    201 #else /* HAS_UBOOT */
    202   calc_dbat_regvals(&dbat,(uint32_t) bsp_ram_start,(uint32_t) bsp_ram_size,0,0,0,0,BPP_RW);
    203 #endif /* HAS_UBOOT */
    204 
    205   SET_DBAT(0,dbat.batu,dbat.batl);
    206 
    207 #ifdef HAS_UBOOT
    208   calc_dbat_regvals(&dbat,mpc83xx_uboot_board_info.bi_flashstart,mpc83xx_uboot_board_info.bi_flashsize,0,0,0,0,BPP_RX);
    209 #else /* HAS_UBOOT */
    210   calc_dbat_regvals(&dbat,(uint32_t) bsp_rom_start,(uint32_t) bsp_rom_size,0,0,0,0,BPP_RX);
    211 #endif /* HAS_UBOOT */
    212 
    213   SET_DBAT(1,dbat.batu,dbat.batl);
    214 
    215 #ifdef HAS_UBOOT
    216   calc_dbat_regvals(&dbat,mpc83xx_uboot_board_info.bi_immrbar,1024*1024,0,1,0,1,BPP_RW);
    217 #else /* HAS_UBOOT */
    218   calc_dbat_regvals(&dbat,(uint32_t) IMMRBAR,1024*1024,0,1,0,1,BPP_RW);
    219 #endif /* HAS_UBOOT */
    220 
    221   SET_DBAT(2,dbat.batu,dbat.batl);
     204
     205  memset(&dbat, 0, sizeof( dbat));
     206  SET_DBAT( 3, dbat.batu, dbat.batl);
     207  SET_DBAT( 4, dbat.batu, dbat.batl);
     208  SET_DBAT( 5, dbat.batu, dbat.batl);
     209  SET_DBAT( 6, dbat.batu, dbat.batl);
     210  SET_DBAT( 7, dbat.batu, dbat.batl);
     211
     212  calc_dbat_regvals(
     213    &dbat,
     214    #ifdef HAS_UBOOT
     215      mpc83xx_uboot_board_info.bi_memstart,
     216      mpc83xx_uboot_board_info.bi_memsize,
     217    #else /* HAS_UBOOT */
     218      (uint32_t) bsp_ram_start,
     219      (uint32_t) bsp_ram_size,
     220    #endif /* HAS_UBOOT */
     221    false,
     222    false,
     223    false,
     224    false,
     225    BPP_RW
     226  );
     227  SET_DBAT( 0, dbat.batu, dbat.batl);
     228
     229  calc_dbat_regvals(
     230    &dbat,
     231    #ifdef HAS_UBOOT
     232      mpc83xx_uboot_board_info.bi_flashstart,
     233      mpc83xx_uboot_board_info.bi_flashsize,
     234    #else /* HAS_UBOOT */
     235      (uint32_t) bsp_rom_start,
     236      (uint32_t) bsp_rom_size,
     237    #endif /* HAS_UBOOT */
     238    false,
     239    false,
     240    false,
     241    false,
     242    BPP_RX
     243  );
     244  SET_DBAT( 1, dbat.batu, dbat.batl);
     245
     246  calc_dbat_regvals(
     247    &dbat,
     248    #ifdef HAS_UBOOT
     249      mpc83xx_uboot_board_info.bi_immrbar,
     250    #else /* HAS_UBOOT */
     251      (uint32_t) IMMRBAR,
     252    #endif /* HAS_UBOOT */
     253    1024 * 1024,
     254    false,
     255    true,
     256    false,
     257    true,
     258    BPP_RW
     259  );
     260  SET_DBAT( 2, dbat.batu, dbat.batl);
    222261
    223262#ifdef MPC8313ERDB
    224263  /* Enhanced Local Bus Controller (eLBC) */
    225   calc_dbat_regvals( &dbat, 0xfa000000, 128 * 1024, 0, 1, 0, 1, BPP_RW);
     264  calc_dbat_regvals(
     265    &dbat,
     266    0xfa000000,
     267    128 * 1024,
     268    false,
     269    true,
     270    false,
     271    true,
     272    BPP_RW
     273  );
    226274  SET_DBAT( 3, dbat.batu, dbat.batl);
    227275#endif /* MPC8313ERDB */
    228276
     277  /* Read MSR */
     278  msr = ppc_machine_state_register();
     279
     280  /* Enable data and instruction MMU in MSR */
     281  msr |= MSR_DR | MSR_IR;
     282
     283  /* Enable FPU in MSR */
     284  msr |= MSR_FP;
     285
     286  /* Update MSR */
     287  ppc_set_machine_state_register( msr);
     288
    229289  /*
    230    * enable data/instruction MMU in MSR
     290   * In HID0:
     291   *  - Enable dynamic power management
     292   *  - Enable machine check interrupts
    231293   */
    232   _write_MSR(_read_MSR() | MSR_DR | MSR_IR);
    233 
    234   /*
    235    * enable FPU in MSR
    236    */
    237   _write_MSR(_read_MSR() | MSR_FP);
    238 
    239   /*
    240    * in HID0:
    241    * - enable dynamic power management
    242    * - enable machine check interrupts
    243    */
    244   GET_HID0(reg);
    245   reg |=  (HID0_EMCP | HID0_DPM) ;
    246   SET_HID0(reg);
    247 
    248   /*
    249    * enable timebase clock
    250    */
     294  PPC_SET_SPECIAL_PURPOSE_REGISTER_BITS( HID0, HID0_EMCP | HID0_DPM);
     295
     296  /* Enable timebase clock */
    251297  mpc83xx.syscon.spcr |= M83xx_SYSCON_SPCR_TBEN;
    252298}
Note: See TracChangeset for help on using the changeset viewer.