board/freescale/qemu-ppce500/qemu-ppce500.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2007,2009-2014 Freescale Semiconductor, Inc.
   4  */
   5
   6 #include <common.h>
   7 #include <command.h>
   8 #include <cpu_func.h>
   9 #include <env.h>
  10 #include <init.h>
  11 #include <net.h>
  12 #include <pci.h>
  13 #include <time.h>
  14 #include <asm/processor.h>
  15 #include <asm/mmu.h>
  16 #include <asm/fsl_pci.h>
  17 #include <asm/io.h>
  18 #include <linux/libfdt.h>
  19 #include <fdt_support.h>
  20 #include <netdev.h>
  21 #include <fdtdec.h>
  22 #include <errno.h>
  23 #include <malloc.h>
  24
  25 DECLARE_GLOBAL_DATA_PTR;
  26
  27 static void *get_fdt_virt(void)
  28 {
  29         return (void *)CONFIG_SYS_TMPVIRT;
  30 }
  31
  32 static uint64_t get_fdt_phys(void)
  33 {
  34         return (uint64_t)(uintptr_t)gd->fdt_blob;
  35 }
  36
  37 static void map_fdt_as(int esel)
  38 {
  39         u32 mas0, mas1, mas2, mas3, mas7;
  40         uint64_t fdt_phys = get_fdt_phys();
  41         unsigned long fdt_phys_tlb = fdt_phys & ~0xffffful;
  42         unsigned long fdt_virt_tlb = (ulong)get_fdt_virt() & ~0xffffful;
  43
  44         mas0 = MAS0_TLBSEL(1) | MAS0_ESEL(esel);
  45         mas1 = MAS1_VALID | MAS1_TID(0) | MAS1_TS | MAS1_TSIZE(BOOKE_PAGESZ_1M);
  46         mas2 = FSL_BOOKE_MAS2(fdt_virt_tlb, 0);
  47         mas3 = FSL_BOOKE_MAS3(fdt_phys_tlb, 0, MAS3_SW|MAS3_SR);
  48         mas7 = FSL_BOOKE_MAS7(fdt_phys_tlb);
  49
  50         write_tlb(mas0, mas1, mas2, mas3, mas7);
  51 }
  52
  53 uint64_t get_phys_ccsrbar_addr_early(void)
  54 {
  55         void *fdt = get_fdt_virt();
  56         uint64_t r;
  57         int size, node;
  58         u32 naddr;
  59         const fdt32_t *prop;
  60
  61         /*
  62          * To be able to read the FDT we need to create a temporary TLB
  63          * map for it.
  64          */
  65         map_fdt_as(10);
  66         node = fdt_path_offset(fdt, "/soc");
  67         naddr = fdt_address_cells(fdt, node);
  68         prop = fdt_getprop(fdt, node, "ranges", &size);
  69         r = fdt_translate_address(fdt, node, prop + naddr);
  70         disable_tlb(10);
  71
  72         return r;
  73 }
  74
  75 int board_early_init_f(void)
  76 {
  77         return 0;
  78 }
  79
  80 int checkboard(void)
  81 {
  82         return 0;
  83 }
  84
  85 static int pci_map_region(void *fdt, int pci_node, int range_id,
  86                           phys_size_t *ppaddr, pci_addr_t *pvaddr,
  87                           pci_size_t *psize, ulong *pmap_addr)
  88 {
  89         uint64_t addr;
  90         uint64_t size;
  91         ulong map_addr;
  92         int r;
  93
  94         r = fdt_read_range(fdt, pci_node, range_id, NULL, &addr, &size);
  95         if (r)
  96                 return r;
  97
  98         if (ppaddr)
  99                 *ppaddr = addr;
 100         if (psize)
 101                 *psize = size;
 102
 103         if (!pmap_addr)
 104                 return 0;
 105
 106         map_addr = *pmap_addr;
 107
 108         /* Align map_addr */
 109         map_addr += size - 1;
 110         map_addr &= ~(size - 1);
 111
 112         if (map_addr + size >= CONFIG_SYS_PCI_MAP_END)
 113                 return -1;
 114
 115         /* Map virtual memory for range */
 116         assert(!tlb_map_range(map_addr, addr, size, TLB_MAP_IO));
 117         *pmap_addr = map_addr + size;
 118
 119         if (pvaddr)
 120                 *pvaddr = map_addr;
 121
 122         return 0;
 123 }
 124
 125 void pci_init_board(void)
 126 {
 127         struct pci_controller *pci_hoses;
 128         void *fdt = get_fdt_virt();
 129         int pci_node = -1;
 130         int pci_num = 0;
 131         int pci_count = 0;
 132         ulong map_addr;
 133
 134         puts("\n");
 135
 136         /* Start MMIO and PIO range maps above RAM */
 137         map_addr = CONFIG_SYS_PCI_MAP_START;
 138
 139         /* Count and allocate PCI buses */
 140         pci_node = fdt_node_offset_by_prop_value(fdt, pci_node,
 141                         "device_type", "pci", 4);
 142         while (pci_node != -FDT_ERR_NOTFOUND) {
 143                 pci_node = fdt_node_offset_by_prop_value(fdt, pci_node,
 144                                 "device_type", "pci", 4);
 145                 pci_count++;
 146         }
 147
 148         if (pci_count) {
 149                 pci_hoses = malloc(sizeof(struct pci_controller) * pci_count);
 150         } else {
 151                 printf("PCI: disabled\n\n");
 152                 return;
 153         }
 154
 155         /* Spawn PCI buses based on device tree */
 156         pci_node = fdt_node_offset_by_prop_value(fdt, pci_node,
 157                         "device_type", "pci", 4);
 158         while (pci_node != -FDT_ERR_NOTFOUND) {
 159                 struct fsl_pci_info pci_info = { };
 160                 const fdt32_t *reg;
 161                 int r;
 162
 163                 reg = fdt_getprop(fdt, pci_node, "reg", NULL);
 164                 pci_info.regs = fdt_translate_address(fdt, pci_node, reg);
 165
 166                 /* Map MMIO range */
 167                 r = pci_map_region(fdt, pci_node, 0, &pci_info.mem_phys, NULL,
 168                                    &pci_info.mem_size, &map_addr);
 169                 if (r)
 170                         break;
 171
 172                 /* Map PIO range */
 173                 r = pci_map_region(fdt, pci_node, 1, &pci_info.io_phys, NULL,
 174                                    &pci_info.io_size, &map_addr);
 175                 if (r)
 176                         break;
 177
 178                 /*
 179                  * The PCI framework finds virtual addresses for the buses
 180                  * through our address map, so tell it the physical addresses.
 181                  */
 182                 pci_info.mem_bus = pci_info.mem_phys;
 183                 pci_info.io_bus = pci_info.io_phys;
 184
 185                 /* Instantiate */
 186                 pci_info.pci_num = pci_num + 1;
 187
 188                 fsl_setup_hose(&pci_hoses[pci_num], pci_info.regs);
 189                 printf("PCI: base address %lx\n", pci_info.regs);
 190
 191                 fsl_pci_init_port(&pci_info, &pci_hoses[pci_num], pci_num);
 192
 193                 /* Jump to next PCI node */
 194                 pci_node = fdt_node_offset_by_prop_value(fdt, pci_node,
 195                                 "device_type", "pci", 4);
 196                 pci_num++;
 197         }
 198
 199         puts("\n");
 200 }
 201
 202 int last_stage_init(void)
 203 {
 204         void *fdt = get_fdt_virt();
 205         int len = 0;
 206         const uint64_t *prop;
 207         int chosen;
 208
 209         chosen = fdt_path_offset(fdt, "/chosen");
 210         if (chosen < 0) {
 211                 printf("Couldn't find /chosen node in fdt\n");
 212                 return -EIO;
 213         }
 214
 215         /* -kernel boot */
 216         prop = fdt_getprop(fdt, chosen, "qemu,boot-kernel", &len);
 217         if (prop && (len >= 8))
 218                 env_set_hex("qemu_kernel_addr", *prop);
 219
 220         /* Give the user a variable for the host fdt */
 221         env_set_hex("fdt_addr_r", (ulong)fdt);
 222
 223         return 0;
 224 }
 225
 226 static uint64_t get_linear_ram_size(void)
 227 {
 228         void *fdt = get_fdt_virt();
 229         const void *prop;
 230         int memory;
 231         int len;
 232
 233         memory = fdt_path_offset(fdt, "/memory");
 234         prop = fdt_getprop(fdt, memory, "reg", &len);
 235
 236         if (prop && len >= 16)
 237                 return *(uint64_t *)(prop+8);
 238
 239         panic("Couldn't determine RAM size");
 240 }
 241
 242 int board_eth_init(bd_t *bis)
 243 {
 244         return pci_eth_init(bis);
 245 }
 246
 247 #if defined(CONFIG_OF_BOARD_SETUP)
 248 int ft_board_setup(void *blob, bd_t *bd)
 249 {
 250         FT_FSL_PCI_SETUP;
 251
 252         return 0;
 253 }
 254 #endif
 255
 256 void print_laws(void)
 257 {
 258         /* We don't emulate LAWs yet */
 259 }
 260
 261 phys_size_t fixed_sdram(void)
 262 {
 263         return get_linear_ram_size();
 264 }
 265
 266 phys_size_t fsl_ddr_sdram_size(void)
 267 {
 268         return get_linear_ram_size();
 269 }
 270
 271 void init_tlbs(void)
 272 {
 273         phys_size_t ram_size;
 274
 275         /*
 276          * Create a temporary AS=1 map for the fdt
 277          *
 278          * We use ESEL=0 here to overwrite the previous AS=0 map for ourselves
 279          * which was only 4k big. This way we don't have to clear any other maps.
 280          */
 281         map_fdt_as(0);
 282
 283         /* Fetch RAM size from the fdt */
 284         ram_size = get_linear_ram_size();
 285
 286         /* And remove our fdt map again */
 287         disable_tlb(0);
 288
 289         /* Create an internal map of manually created TLB maps */
 290         init_used_tlb_cams();
 291
 292         /* Create a dynamic AS=0 CCSRBAR mapping */
 293         assert(!tlb_map_range(CONFIG_SYS_CCSRBAR, CONFIG_SYS_CCSRBAR_PHYS,
 294                               1024 * 1024, TLB_MAP_IO));
 295
 296         /* Create a RAM map that spans all accessible RAM */
 297         setup_ddr_tlbs(ram_size >> 20);
 298
 299         /* Create a map for the TLB */
 300         assert(!tlb_map_range((ulong)get_fdt_virt(), get_fdt_phys(),
 301                               1024 * 1024, TLB_MAP_RAM));
 302 }
 303
 304 void init_laws(void)
 305 {
 306         /* We don't emulate LAWs yet */
 307 }
 308
 309 static uint32_t get_cpu_freq(void)
 310 {
 311         void *fdt = get_fdt_virt();
 312         int cpus_node = fdt_path_offset(fdt, "/cpus");
 313         int cpu_node = fdt_first_subnode(fdt, cpus_node);
 314         const char *prop = "clock-frequency";
 315         return fdt_getprop_u32_default_node(fdt, cpu_node, 0, prop, 0);
 316 }
 317
 318 void get_sys_info(sys_info_t *sys_info)
 319 {
 320         int freq = get_cpu_freq();
 321
 322         memset(sys_info, 0, sizeof(sys_info_t));
 323         sys_info->freq_systembus = freq;
 324         sys_info->freq_ddrbus = freq;
 325         sys_info->freq_processor[0] = freq;
 326 }
 327
 328 int get_clocks(void)
 329 {
 330         sys_info_t sys_info;
 331
 332         get_sys_info(&sys_info);
 333
 334         gd->cpu_clk = sys_info.freq_processor[0];
 335         gd->bus_clk = sys_info.freq_systembus;
 336         gd->mem_clk = sys_info.freq_ddrbus;
 337         gd->arch.lbc_clk = sys_info.freq_ddrbus;
 338
 339         return 0;
 340 }
 341
 342 unsigned long get_tbclk(void)
 343 {
 344         void *fdt = get_fdt_virt();
 345         int cpus_node = fdt_path_offset(fdt, "/cpus");
 346         int cpu_node = fdt_first_subnode(fdt, cpus_node);
 347         const char *prop = "timebase-frequency";
 348         return fdt_getprop_u32_default_node(fdt, cpu_node, 0, prop, 0);
 349 }
 350
 351 /********************************************
 352  * get_bus_freq
 353  * return system bus freq in Hz
 354  *********************************************/
 355 ulong get_bus_freq(ulong dummy)
 356 {
 357         sys_info_t sys_info;
 358         get_sys_info(&sys_info);
 359         return sys_info.freq_systembus;
 360 }
 361
 362 /*
 363  * Return the number of cores on this SOC.
 364  */
 365 int cpu_numcores(void)
 366 {
 367         /*
 368          * The QEMU u-boot target only needs to drive the first core,
 369          * spinning and device tree nodes get driven by QEMU itself
 370          */
 371         return 1;
 372 }
 373
 374 /*
 375  * Return a 32-bit mask indicating which cores are present on this SOC.
 376  */
 377 u32 cpu_mask(void)
 378 {
 379         return (1 << cpu_numcores()) - 1;
 380 }