git.sur5r.net Git - u-boot/blob - arch/arm/mach-keystone/init.c

   1 /*
   2  * Keystone2: Architecture initialization
   3  *
   4  * (C) Copyright 2012-2014
   5  *     Texas Instruments Incorporated, <www.ti.com>
   6  *
   7  * SPDX-License-Identifier:     GPL-2.0+
   8  */
   9
  10 #include <common.h>
  11 #include <ns16550.h>
  12 #include <asm/io.h>
  13 #include <asm/arch/msmc.h>
  14 #include <asm/arch/clock.h>
  15 #include <asm/arch/hardware.h>
  16 #include <asm/arch/psc_defs.h>
  17
  18 #define MAX_PCI_PORTS           2
  19 enum pci_mode   {
  20         ENDPOINT,
  21         LEGACY_ENDPOINT,
  22         ROOTCOMPLEX,
  23 };
  24
  25 #define DEVCFG_MODE_MASK                (BIT(2) | BIT(1))
  26 #define DEVCFG_MODE_SHIFT               1
  27
  28 void chip_configuration_unlock(void)
  29 {
  30         __raw_writel(KS2_KICK0_MAGIC, KS2_KICK0);
  31         __raw_writel(KS2_KICK1_MAGIC, KS2_KICK1);
  32 }
  33
  34 #ifdef CONFIG_SOC_K2L
  35 void osr_init(void)
  36 {
  37         u32 i;
  38         u32 j;
  39         u32 val;
  40         u32 base = KS2_OSR_CFG_BASE;
  41         u32 ecc_ctrl[KS2_OSR_NUM_RAM_BANKS];
  42
  43         /* Enable the OSR clock domain */
  44         psc_enable_module(KS2_LPSC_OSR);
  45
  46         /* Disable OSR ECC check for all the ram banks */
  47         for (i = 0; i < KS2_OSR_NUM_RAM_BANKS; i++) {
  48                 val = i | KS2_OSR_ECC_VEC_TRIG_RD |
  49                         (KS2_OSR_ECC_CTRL << KS2_OSR_ECC_VEC_RD_ADDR_SH);
  50
  51                 writel(val , base + KS2_OSR_ECC_VEC);
  52
  53                 /**
  54                  * wait till read is done.
  55                  * Print should be added after earlyprintk support is added.
  56                  */
  57                 for (j = 0; j < 10000; j++) {
  58                         val = readl(base + KS2_OSR_ECC_VEC);
  59                         if (val & KS2_OSR_ECC_VEC_RD_DONE)
  60                                 break;
  61                 }
  62
  63                 ecc_ctrl[i] = readl(base + KS2_OSR_ECC_CTRL) ^
  64                                                 KS2_OSR_ECC_CTRL_CHK;
  65
  66                 writel(ecc_ctrl[i], KS2_MSMC_DATA_BASE + i * 4);
  67                 writel(ecc_ctrl[i], base + KS2_OSR_ECC_CTRL);
  68         }
  69
  70         /* Reset OSR memory to all zeros */
  71         for (i = 0; i < KS2_OSR_SIZE; i += 4)
  72                 writel(0, KS2_OSR_DATA_BASE + i);
  73
  74         /* Enable OSR ECC check for all the ram banks */
  75         for (i = 0; i < KS2_OSR_NUM_RAM_BANKS; i++)
  76                 writel(ecc_ctrl[i] |
  77                        KS2_OSR_ECC_CTRL_CHK, base + KS2_OSR_ECC_CTRL);
  78 }
  79 #endif
  80
  81 /* Function to set up PCIe mode */
  82 static void config_pcie_mode(int pcie_port,  enum pci_mode mode)
  83 {
  84         u32 val = __raw_readl(KS2_DEVCFG);
  85
  86         if (pcie_port >= MAX_PCI_PORTS)
  87                 return;
  88
  89         /**
  90          * each pci port has two bits for mode and it starts at
  91          * bit 1. So use port number to get the right bit position.
  92          */
  93         pcie_port <<= 1;
  94         val &= ~(DEVCFG_MODE_MASK << pcie_port);
  95         val |= ((mode << DEVCFG_MODE_SHIFT) << pcie_port);
  96         __raw_writel(val, KS2_DEVCFG);
  97 }
  98
  99 static void msmc_k2hkle_common_setup(void)
 100 {
 101         msmc_share_all_segments(K2HKLE_MSMC_SEGMENT_ARM);
 102         msmc_share_all_segments(K2HKLE_MSMC_SEGMENT_NETCP);
 103 #ifdef KS2_MSMC_SEGMENT_QM_PDSP
 104         msmc_share_all_segments(K2HKLE_MSMC_SEGMENT_QM_PDSP);
 105 #endif
 106         msmc_share_all_segments(K2HKLE_MSMC_SEGMENT_PCIE0);
 107 }
 108
 109 static inline void msmc_k2l_setup(void)
 110 {
 111         msmc_share_all_segments(K2L_MSMC_SEGMENT_PCIE1);
 112 }
 113
 114 static inline void msmc_k2e_setup(void)
 115 {
 116         msmc_share_all_segments(K2E_MSMC_SEGMENT_PCIE1);
 117 }
 118
 119 static inline void msmc_k2g_setup(void)
 120 {
 121         msmc_share_all_segments(K2G_MSMC_SEGMENT_ARM);
 122         msmc_share_all_segments(K2G_MSMC_SEGMENT_NSS);
 123         msmc_share_all_segments(K2G_MSMC_SEGMENT_PCIE);
 124 }
 125
 126 int arch_cpu_init(void)
 127 {
 128         chip_configuration_unlock();
 129         icache_enable();
 130
 131         if (cpu_is_k2g()) {
 132                 msmc_k2g_setup();
 133         } else {
 134                 msmc_k2hkle_common_setup();
 135                 if (cpu_is_k2e())
 136                         msmc_k2e_setup();
 137                 else if (cpu_is_k2l())
 138                         msmc_k2l_setup();
 139         }
 140
 141         /* Initialize the PCIe-0 to work as Root Complex */
 142         config_pcie_mode(0, ROOTCOMPLEX);
 143 #if defined(CONFIG_SOC_K2E) || defined(CONFIG_SOC_K2L)
 144         /* Initialize the PCIe-1 to work as Root Complex */
 145         config_pcie_mode(1, ROOTCOMPLEX);
 146 #endif
 147 #ifdef CONFIG_SOC_K2L
 148         osr_init();
 149 #endif
 150
 151         /*
 152          * just initialise the COM2 port so that TI specific
 153          * UART register PWREMU_MGMT is initialized. Linux UART
 154          * driver doesn't handle this.
 155          */
 156 #ifndef CONFIG_DM_SERIAL
 157         NS16550_init((NS16550_t)(CONFIG_SYS_NS16550_COM2),
 158                      CONFIG_SYS_NS16550_CLK / 16 / CONFIG_BAUDRATE);
 159 #endif
 160
 161         return 0;
 162 }
 163
 164 void reset_cpu(ulong addr)
 165 {
 166         volatile u32 *rstctrl = (volatile u32 *)(KS2_RSTCTRL);
 167         u32 tmp;
 168
 169         tmp = *rstctrl & KS2_RSTCTRL_MASK;
 170         *rstctrl = tmp | KS2_RSTCTRL_KEY;
 171
 172         *rstctrl &= KS2_RSTCTRL_SWRST;
 173
 174         for (;;)
 175                 ;
 176 }
 177
 178 void enable_caches(void)
 179 {
 180 #ifndef CONFIG_SYS_DCACHE_OFF
 181         /* Enable D-cache. I-cache is already enabled in start.S */
 182         dcache_enable();
 183 #endif
 184 }
 185
 186 #if defined(CONFIG_DISPLAY_CPUINFO)
 187 int print_cpuinfo(void)
 188 {
 189         u16 cpu = get_part_number();
 190         u8 rev = cpu_revision();
 191
 192         puts("CPU: ");
 193         switch (cpu) {
 194         case CPU_66AK2Hx:
 195                 puts("66AK2Hx SR");
 196                 break;
 197         case CPU_66AK2Lx:
 198                 puts("66AK2Lx SR");
 199                 break;
 200         case CPU_66AK2Ex:
 201                 puts("66AK2Ex SR");
 202                 break;
 203         case CPU_66AK2Gx:
 204                 puts("66AK2Gx SR");
 205                 break;
 206         default:
 207                 puts("Unknown\n");
 208         }
 209
 210         if (rev == 2)
 211                 puts("2.0\n");
 212         else if (rev == 1)
 213                 puts("1.1\n");
 214         else if (rev == 0)
 215                 puts("1.0\n");
 216
 217         return 0;
 218 }
 219 #endif