mv_machdep.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * Copyright (c) 1994-1998 Mark Brinicombe.
    3  * Copyright (c) 1994 Brini.
    4  * All rights reserved.
    5  *
    6  * This code is derived from software written for Brini by Mark Brinicombe
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. All advertising materials mentioning features or use of this software
   17  *    must display the following acknowledgement:
   18  *      This product includes software developed by Brini.
   19  * 4. The name of the company nor the name of the author may be used to
   20  *    endorse or promote products derived from this software without specific
   21  *    prior written permission.
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY BRINI ``AS IS'' AND ANY EXPRESS OR IMPLIED
   24  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
   25  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   26  * IN NO EVENT SHALL BRINI OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
   27  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   28  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   29  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   33  * SUCH DAMAGE.
   34  *
   35  * from: FreeBSD: //depot/projects/arm/src/sys/arm/at91/kb920x_machdep.c, rev 45
   36  */
   37 
   38 #include "opt_msgbuf.h"
   39 #include "opt_ddb.h"
   40 
   41 #include <sys/cdefs.h>
   42 __FBSDID("$FreeBSD: releng/8.1/sys/arm/mv/mv_machdep.c 204730 2010-03-04 20:22:48Z raj $");
   43 
   44 #define _ARM32_BUS_DMA_PRIVATE
   45 #include <sys/param.h>
   46 #include <sys/systm.h>
   47 #include <sys/sysproto.h>
   48 #include <sys/signalvar.h>
   49 #include <sys/imgact.h>
   50 #include <sys/kernel.h>
   51 #include <sys/ktr.h>
   52 #include <sys/linker.h>
   53 #include <sys/lock.h>
   54 #include <sys/malloc.h>
   55 #include <sys/mutex.h>
   56 #include <sys/pcpu.h>
   57 #include <sys/proc.h>
   58 #include <sys/ptrace.h>
   59 #include <sys/cons.h>
   60 #include <sys/bio.h>
   61 #include <sys/bus.h>
   62 #include <sys/buf.h>
   63 #include <sys/exec.h>
   64 #include <sys/kdb.h>
   65 #include <sys/msgbuf.h>
   66 #include <machine/reg.h>
   67 #include <machine/cpu.h>
   68 
   69 #include <vm/vm.h>
   70 #include <vm/pmap.h>
   71 #include <vm/vm_object.h>
   72 #include <vm/vm_page.h>
   73 #include <vm/vm_pager.h>
   74 #include <vm/vm_map.h>
   75 #include <vm/vnode_pager.h>
   76 #include <machine/pte.h>
   77 #include <machine/pmap.h>
   78 #include <machine/vmparam.h>
   79 #include <machine/pcb.h>
   80 #include <machine/undefined.h>
   81 #include <machine/machdep.h>
   82 #include <machine/metadata.h>
   83 #include <machine/armreg.h>
   84 #include <machine/bus.h>
   85 #include <sys/reboot.h>
   86 #include <machine/bootinfo.h>
   87 
   88 #include <arm/mv/mvvar.h>       /* XXX eventually this should be eliminated */
   89 #include <arm/mv/mvwin.h>
   90 
   91 #ifdef  DEBUG
   92 #define debugf(fmt, args...) printf(fmt, ##args)
   93 #else
   94 #define debugf(fmt, args...)
   95 #endif
   96 
   97 /*
   98  * This is the number of L2 page tables required for covering max
   99  * (hypothetical) memsize of 4GB and all kernel mappings (vectors, msgbuf,
  100  * stacks etc.), uprounded to be divisible by 4.
  101  */
  102 #define KERNEL_PT_MAX   78
  103 
  104 /* Define various stack sizes in pages */
  105 #define IRQ_STACK_SIZE  1
  106 #define ABT_STACK_SIZE  1
  107 #define UND_STACK_SIZE  1
  108 
  109 /* Maximum number of memory regions */
  110 #define MEM_REGIONS     8
  111 
  112 extern unsigned char kernbase[];
  113 extern unsigned char _etext[];
  114 extern unsigned char _edata[];
  115 extern unsigned char __bss_start[];
  116 extern unsigned char _end[];
  117 
  118 extern u_int data_abort_handler_address;
  119 extern u_int prefetch_abort_handler_address;
  120 extern u_int undefined_handler_address;
  121 
  122 extern const struct pmap_devmap *pmap_devmap_bootstrap_table;
  123 extern vm_offset_t pmap_bootstrap_lastaddr;
  124 
  125 struct pv_addr kernel_pt_table[KERNEL_PT_MAX];
  126 
  127 extern int *end;
  128 
  129 struct pcpu __pcpu;
  130 struct pcpu *pcpup = &__pcpu;
  131 
  132 /* Physical and virtual addresses for some global pages */
  133 
  134 vm_paddr_t phys_avail[10];
  135 vm_paddr_t dump_avail[4];
  136 vm_offset_t physical_pages;
  137 vm_offset_t pmap_bootstrap_lastaddr;
  138 
  139 const struct pmap_devmap *pmap_devmap_bootstrap_table;
  140 struct pv_addr systempage;
  141 struct pv_addr msgbufpv;
  142 struct pv_addr irqstack;
  143 struct pv_addr undstack;
  144 struct pv_addr abtstack;
  145 struct pv_addr kernelstack;
  146 
  147 static struct trapframe proc0_tf;
  148 
  149 struct mem_region {
  150         vm_offset_t     mr_start;
  151         vm_size_t       mr_size;
  152 };
  153 
  154 static struct mem_region availmem_regions[MEM_REGIONS];
  155 static int availmem_regions_sz;
  156 
  157 struct bootinfo *bootinfo;
  158 
  159 static void print_kenv(void);
  160 static void print_kernel_section_addr(void);
  161 static void print_bootinfo(void);
  162 
  163 static void physmap_init(int);
  164 
  165 static char *
  166 kenv_next(char *cp)
  167 {
  168 
  169         if (cp != NULL) {
  170                 while (*cp != 0)
  171                         cp++;
  172                 cp++;
  173                 if (*cp == 0)
  174                         cp = NULL;
  175         }
  176         return (cp);
  177 }
  178 
  179 static void
  180 print_kenv(void)
  181 {
  182         int len;
  183         char *cp;
  184 
  185         debugf("loader passed (static) kenv:\n");
  186         if (kern_envp == NULL) {
  187                 debugf(" no env, null ptr\n");
  188                 return;
  189         }
  190         debugf(" kern_envp = 0x%08x\n", (uint32_t)kern_envp);
  191 
  192         len = 0;
  193         for (cp = kern_envp; cp != NULL; cp = kenv_next(cp))
  194                 debugf(" %x %s\n", (uint32_t)cp, cp);
  195 }
  196 
  197 static void
  198 print_bootinfo(void)
  199 {
  200         struct bi_mem_region *mr;
  201         struct bi_eth_addr *eth;
  202         int i, j;
  203 
  204         debugf("bootinfo:\n");
  205         if (bootinfo == NULL) {
  206                 debugf(" no bootinfo, null ptr\n");
  207                 return;
  208         }
  209 
  210         debugf(" version = 0x%08x\n", bootinfo->bi_version);
  211         debugf(" ccsrbar = 0x%08x\n", bootinfo->bi_bar_base);
  212         debugf(" cpu_clk = 0x%08x\n", bootinfo->bi_cpu_clk);
  213         debugf(" bus_clk = 0x%08x\n", bootinfo->bi_bus_clk);
  214 
  215         debugf(" mem regions:\n");
  216         mr = (struct bi_mem_region *)bootinfo->bi_data;
  217         for (i = 0; i < bootinfo->bi_mem_reg_no; i++, mr++)
  218                 debugf("    #%d, base = 0x%08x, size = 0x%08x\n", i,
  219                     mr->mem_base, mr->mem_size);
  220 
  221         debugf(" eth addresses:\n");
  222         eth = (struct bi_eth_addr *)mr;
  223         for (i = 0; i < bootinfo->bi_eth_addr_no; i++, eth++) {
  224                 debugf("    #%d, addr = ", i);
  225                 for (j = 0; j < 6; j++)
  226                         debugf("%02x ", eth->mac_addr[j]);
  227                 debugf("\n");
  228         }
  229 }
  230 
  231 static void
  232 print_kernel_section_addr(void)
  233 {
  234 
  235         debugf("kernel image addresses:\n");
  236         debugf(" kernbase       = 0x%08x\n", (uint32_t)kernbase);
  237         debugf(" _etext (sdata) = 0x%08x\n", (uint32_t)_etext);
  238         debugf(" _edata         = 0x%08x\n", (uint32_t)_edata);
  239         debugf(" __bss_start    = 0x%08x\n", (uint32_t)__bss_start);
  240         debugf(" _end           = 0x%08x\n", (uint32_t)_end);
  241 }
  242 
  243 struct bi_mem_region *
  244 bootinfo_mr(void)
  245 {
  246 
  247         return ((struct bi_mem_region *)bootinfo->bi_data);
  248 }
  249 
  250 static void
  251 physmap_init(int hardcoded)
  252 {
  253         int i, j, cnt;
  254         vm_offset_t phys_kernelend, kernload;
  255         uint32_t s, e, sz;
  256         struct mem_region *mp, *mp1;
  257 
  258         phys_kernelend = KERNPHYSADDR + (virtual_avail - KERNVIRTADDR);
  259         kernload = KERNPHYSADDR;
  260 
  261         /*
  262          * Use hardcoded physical addresses if we don't use memory regions
  263          * from metadata.
  264          */
  265         if (hardcoded) {
  266                 phys_avail[0] = 0;
  267                 phys_avail[1] = kernload;
  268 
  269                 phys_avail[2] = phys_kernelend;
  270                 phys_avail[3] = PHYSMEM_SIZE;
  271 
  272                 phys_avail[4] = 0;
  273                 phys_avail[5] = 0;
  274                 return;
  275         }
  276 
  277         /*
  278          * Remove kernel physical address range from avail
  279          * regions list. Page align all regions.
  280          * Non-page aligned memory isn't very interesting to us.
  281          * Also, sort the entries for ascending addresses.
  282          */
  283         sz = 0;
  284         cnt = availmem_regions_sz;
  285         debugf("processing avail regions:\n");
  286         for (mp = availmem_regions; mp->mr_size; mp++) {
  287                 s = mp->mr_start;
  288                 e = mp->mr_start + mp->mr_size;
  289                 debugf(" %08x-%08x -> ", s, e);
  290                 /* Check whether this region holds all of the kernel. */
  291                 if (s < kernload && e > phys_kernelend) {
  292                         availmem_regions[cnt].mr_start = phys_kernelend;
  293                         availmem_regions[cnt++].mr_size = e - phys_kernelend;
  294                         e = kernload;
  295                 }
  296                 /* Look whether this regions starts within the kernel. */
  297                 if (s >= kernload && s < phys_kernelend) {
  298                         if (e <= phys_kernelend)
  299                                 goto empty;
  300                         s = phys_kernelend;
  301                 }
  302                 /* Now look whether this region ends within the kernel. */
  303                 if (e > kernload && e <= phys_kernelend) {
  304                         if (s >= kernload) {
  305                                 goto empty;
  306                         }
  307                         e = kernload;
  308                 }
  309                 /* Now page align the start and size of the region. */
  310                 s = round_page(s);
  311                 e = trunc_page(e);
  312                 if (e < s)
  313                         e = s;
  314                 sz = e - s;
  315                 debugf("%08x-%08x = %x\n", s, e, sz);
  316 
  317                 /* Check whether some memory is left here. */
  318                 if (sz == 0) {
  319                 empty:
  320                         printf("skipping\n");
  321                         bcopy(mp + 1, mp,
  322                             (cnt - (mp - availmem_regions)) * sizeof(*mp));
  323                         cnt--;
  324                         mp--;
  325                         continue;
  326                 }
  327 
  328                 /* Do an insertion sort. */
  329                 for (mp1 = availmem_regions; mp1 < mp; mp1++)
  330                         if (s < mp1->mr_start)
  331                                 break;
  332                 if (mp1 < mp) {
  333                         bcopy(mp1, mp1 + 1, (char *)mp - (char *)mp1);
  334                         mp1->mr_start = s;
  335                         mp1->mr_size = sz;
  336                 } else {
  337                         mp->mr_start = s;
  338                         mp->mr_size = sz;
  339                 }
  340         }
  341         availmem_regions_sz = cnt;
  342 
  343         /* Fill in phys_avail table, based on availmem_regions */
  344         debugf("fill in phys_avail:\n");
  345         for (i = 0, j = 0; i < availmem_regions_sz; i++, j += 2) {
  346 
  347                 debugf(" region: 0x%08x - 0x%08x (0x%08x)\n",
  348                     availmem_regions[i].mr_start,
  349                     availmem_regions[i].mr_start + availmem_regions[i].mr_size,
  350                     availmem_regions[i].mr_size);
  351 
  352                 phys_avail[j] = availmem_regions[i].mr_start;
  353                 phys_avail[j + 1] = availmem_regions[i].mr_start +
  354                     availmem_regions[i].mr_size;
  355         }
  356         phys_avail[j] = 0;
  357         phys_avail[j + 1] = 0;
  358 }
  359 
  360 void *
  361 initarm(void *mdp, void *unused __unused)
  362 {
  363         struct pv_addr kernel_l1pt;
  364         struct pv_addr dpcpu;
  365         vm_offset_t freemempos, l2_start, lastaddr;
  366         uint32_t memsize, l2size;
  367         struct bi_mem_region *mr;
  368         void *kmdp;
  369         u_int l1pagetable;
  370         int i = 0, j = 0;
  371 
  372         kmdp = NULL;
  373         lastaddr = 0;
  374         memsize = 0;
  375 
  376         set_cpufuncs();
  377 
  378         /*
  379          * Mask metadata pointer: it is supposed to be on page boundary. If
  380          * the first argument (mdp) doesn't point to a valid address the
  381          * bootloader must have passed us something else than the metadata
  382          * ptr... In this case we want to fall back to some built-in settings.
  383          */
  384         mdp = (void *)((uint32_t)mdp & ~PAGE_MASK);
  385 
  386         /* Parse metadata and fetch parameters */
  387         if (mdp != NULL) {
  388                 preload_metadata = mdp;
  389                 kmdp = preload_search_by_type("elf kernel");
  390                 if (kmdp != NULL) {
  391                         bootinfo = (struct bootinfo *)preload_search_info(kmdp,
  392                             MODINFO_METADATA|MODINFOMD_BOOTINFO);
  393 
  394                         boothowto = MD_FETCH(kmdp, MODINFOMD_HOWTO, int);
  395                         kern_envp = MD_FETCH(kmdp, MODINFOMD_ENVP, char *);
  396                         lastaddr = MD_FETCH(kmdp, MODINFOMD_KERNEND, vm_offset_t);
  397                 }
  398 
  399                 /* Initialize memory regions table */
  400                 mr = bootinfo_mr();
  401                 for (i = 0; i < bootinfo->bi_mem_reg_no; i++, mr++) {
  402                         if (i == MEM_REGIONS)
  403                                 break;
  404                         availmem_regions[i].mr_start = mr->mem_base;
  405                         availmem_regions[i].mr_size = mr->mem_size;
  406                         memsize += mr->mem_size;
  407                 }
  408                 availmem_regions_sz = i;
  409         } else {
  410                 /* Fall back to hardcoded metadata. */
  411                 lastaddr = fake_preload_metadata();
  412 
  413                 /*
  414                  * Assume a single memory region of size specified in board
  415                  * configuration file.
  416                  */
  417                 memsize = PHYSMEM_SIZE;
  418         }
  419 
  420         /*
  421          * If memsize is invalid, we can neither proceed nor panic (too
  422          * early for console output).
  423          */
  424         if (memsize == 0)
  425                 while (1);
  426 
  427         /* Platform-specific initialisation */
  428         pmap_bootstrap_lastaddr = MV_BASE - ARM_NOCACHE_KVA_SIZE;
  429         pmap_devmap_bootstrap_table = &pmap_devmap[0];
  430 
  431         pcpu_init(pcpup, 0, sizeof(struct pcpu));
  432         PCPU_SET(curthread, &thread0);
  433 
  434         /* Calculate number of L2 tables needed for mapping vm_page_array */
  435         l2size = (memsize / PAGE_SIZE) * sizeof(struct vm_page);
  436         l2size = (l2size >> L1_S_SHIFT) + 1;
  437 
  438         /*
  439          * Add one table for end of kernel map, one for stacks, msgbuf and
  440          * L1 and L2 tables map and one for vectors map.
  441          */
  442         l2size += 3;
  443 
  444         /* Make it divisible by 4 */
  445         l2size = (l2size + 3) & ~3;
  446 
  447 #define KERNEL_TEXT_BASE (KERNBASE)
  448         freemempos = (lastaddr + PAGE_MASK) & ~PAGE_MASK;
  449 
  450         /* Define a macro to simplify memory allocation */
  451 #define valloc_pages(var, np)                   \
  452         alloc_pages((var).pv_va, (np));         \
  453         (var).pv_pa = (var).pv_va + (KERNPHYSADDR - KERNVIRTADDR);
  454 
  455 #define alloc_pages(var, np)                    \
  456         (var) = freemempos;             \
  457         freemempos += (np * PAGE_SIZE);         \
  458         memset((char *)(var), 0, ((np) * PAGE_SIZE));
  459 
  460         while (((freemempos - L1_TABLE_SIZE) & (L1_TABLE_SIZE - 1)) != 0)
  461                 freemempos += PAGE_SIZE;
  462         valloc_pages(kernel_l1pt, L1_TABLE_SIZE / PAGE_SIZE);
  463 
  464         for (i = 0; i < l2size; ++i) {
  465                 if (!(i % (PAGE_SIZE / L2_TABLE_SIZE_REAL))) {
  466                         valloc_pages(kernel_pt_table[i],
  467                             L2_TABLE_SIZE / PAGE_SIZE);
  468                         j = i;
  469                 } else {
  470                         kernel_pt_table[i].pv_va = kernel_pt_table[j].pv_va +
  471                             L2_TABLE_SIZE_REAL * (i - j);
  472                         kernel_pt_table[i].pv_pa =
  473                             kernel_pt_table[i].pv_va - KERNVIRTADDR +
  474                             KERNPHYSADDR;
  475 
  476                 }
  477         }
  478         /*
  479          * Allocate a page for the system page mapped to 0x00000000
  480          * or 0xffff0000. This page will just contain the system vectors
  481          * and can be shared by all processes.
  482          */
  483         valloc_pages(systempage, 1);
  484 
  485         /* Allocate dynamic per-cpu area. */
  486         valloc_pages(dpcpu, DPCPU_SIZE / PAGE_SIZE);
  487         dpcpu_init((void *)dpcpu.pv_va, 0);
  488 
  489         /* Allocate stacks for all modes */
  490         valloc_pages(irqstack, IRQ_STACK_SIZE);
  491         valloc_pages(abtstack, ABT_STACK_SIZE);
  492         valloc_pages(undstack, UND_STACK_SIZE);
  493         valloc_pages(kernelstack, KSTACK_PAGES);
  494         valloc_pages(msgbufpv, round_page(MSGBUF_SIZE) / PAGE_SIZE);
  495 
  496         /*
  497          * Now we start construction of the L1 page table
  498          * We start by mapping the L2 page tables into the L1.
  499          * This means that we can replace L1 mappings later on if necessary
  500          */
  501         l1pagetable = kernel_l1pt.pv_va;
  502 
  503         /*
  504          * Try to map as much as possible of kernel text and data using
  505          * 1MB section mapping and for the rest of initial kernel address
  506          * space use L2 coarse tables.
  507          *
  508          * Link L2 tables for mapping remainder of kernel (modulo 1MB)
  509          * and kernel structures
  510          */
  511         l2_start = lastaddr & ~(L1_S_OFFSET);
  512         for (i = 0 ; i < l2size - 1; i++)
  513                 pmap_link_l2pt(l1pagetable, l2_start + i * L1_S_SIZE,
  514                     &kernel_pt_table[i]);
  515 
  516         pmap_curmaxkvaddr = l2_start + (l2size - 1) * L1_S_SIZE;
  517         
  518         /* Map kernel code and data */
  519         pmap_map_chunk(l1pagetable, KERNVIRTADDR, KERNPHYSADDR,
  520            (((uint32_t)(lastaddr) - KERNVIRTADDR) + PAGE_MASK) & ~PAGE_MASK,
  521             VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
  522 
  523 
  524         /* Map L1 directory and allocated L2 page tables */
  525         pmap_map_chunk(l1pagetable, kernel_l1pt.pv_va, kernel_l1pt.pv_pa,
  526             L1_TABLE_SIZE, VM_PROT_READ|VM_PROT_WRITE, PTE_PAGETABLE);
  527 
  528         pmap_map_chunk(l1pagetable, kernel_pt_table[0].pv_va,
  529             kernel_pt_table[0].pv_pa,
  530             L2_TABLE_SIZE_REAL * l2size,
  531             VM_PROT_READ|VM_PROT_WRITE, PTE_PAGETABLE);
  532 
  533         /* Map allocated DPCPU, stacks and msgbuf */
  534         pmap_map_chunk(l1pagetable, dpcpu.pv_va, dpcpu.pv_pa,
  535             freemempos - dpcpu.pv_va,
  536             VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
  537 
  538         /* Link and map the vector page */
  539         pmap_link_l2pt(l1pagetable, ARM_VECTORS_HIGH,
  540             &kernel_pt_table[l2size - 1]);
  541         pmap_map_entry(l1pagetable, ARM_VECTORS_HIGH, systempage.pv_pa,
  542             VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
  543 
  544         pmap_devmap_bootstrap(l1pagetable, pmap_devmap_bootstrap_table);
  545         cpu_domains((DOMAIN_CLIENT << (PMAP_DOMAIN_KERNEL * 2)) |
  546             DOMAIN_CLIENT);
  547         setttb(kernel_l1pt.pv_pa);
  548         cpu_tlb_flushID();
  549         cpu_domains(DOMAIN_CLIENT << (PMAP_DOMAIN_KERNEL * 2));
  550         cninit();
  551         physmem = memsize / PAGE_SIZE;
  552 
  553         debugf("initarm: console initialized\n");
  554         debugf(" arg1 mdp = 0x%08x\n", (uint32_t)mdp);
  555         debugf(" boothowto = 0x%08x\n", boothowto);
  556         print_bootinfo();
  557         print_kernel_section_addr();
  558         print_kenv();
  559 
  560         /*
  561          * Re-initialise MPP
  562          */
  563         platform_mpp_init();
  564 
  565         /*
  566          * Re-initialise decode windows
  567          */
  568         if (soc_decode_win() != 0)
  569                 printf("WARNING: could not re-initialise decode windows! "
  570                     "Running with existing settings...\n");
  571         /*
  572          * Pages were allocated during the secondary bootstrap for the
  573          * stacks for different CPU modes.
  574          * We must now set the r13 registers in the different CPU modes to
  575          * point to these stacks.
  576          * Since the ARM stacks use STMFD etc. we must set r13 to the top end
  577          * of the stack memory.
  578          */
  579         cpu_control(CPU_CONTROL_MMU_ENABLE, CPU_CONTROL_MMU_ENABLE);
  580         set_stackptr(PSR_IRQ32_MODE,
  581             irqstack.pv_va + IRQ_STACK_SIZE * PAGE_SIZE);
  582         set_stackptr(PSR_ABT32_MODE,
  583             abtstack.pv_va + ABT_STACK_SIZE * PAGE_SIZE);
  584         set_stackptr(PSR_UND32_MODE,
  585             undstack.pv_va + UND_STACK_SIZE * PAGE_SIZE);
  586 
  587         /*
  588          * We must now clean the cache again....
  589          * Cleaning may be done by reading new data to displace any
  590          * dirty data in the cache. This will have happened in setttb()
  591          * but since we are boot strapping the addresses used for the read
  592          * may have just been remapped and thus the cache could be out
  593          * of sync. A re-clean after the switch will cure this.
  594          * After booting there are no gross relocations of the kernel thus
  595          * this problem will not occur after initarm().
  596          */
  597         cpu_idcache_wbinv_all();
  598 
  599         /* Set stack for exception handlers */
  600         data_abort_handler_address = (u_int)data_abort_handler;
  601         prefetch_abort_handler_address = (u_int)prefetch_abort_handler;
  602         undefined_handler_address = (u_int)undefinedinstruction_bounce;
  603         undefined_init();
  604 
  605         proc_linkup0(&proc0, &thread0);
  606         thread0.td_kstack = kernelstack.pv_va;
  607         thread0.td_kstack_pages = KSTACK_PAGES;
  608         thread0.td_pcb = (struct pcb *)
  609             (thread0.td_kstack + KSTACK_PAGES * PAGE_SIZE) - 1;
  610         thread0.td_pcb->pcb_flags = 0;
  611         thread0.td_frame = &proc0_tf;
  612         pcpup->pc_curpcb = thread0.td_pcb;
  613 
  614         arm_vector_init(ARM_VECTORS_HIGH, ARM_VEC_ALL);
  615 
  616         dump_avail[0] = 0;
  617         dump_avail[1] = memsize;
  618         dump_avail[2] = 0;
  619         dump_avail[3] = 0;
  620 
  621         pmap_bootstrap(freemempos, pmap_bootstrap_lastaddr, &kernel_l1pt);
  622         msgbufp = (void *)msgbufpv.pv_va;
  623         msgbufinit(msgbufp, MSGBUF_SIZE);
  624         mutex_init();
  625 
  626         /*
  627          * Prepare map of physical memory regions available to vm subsystem.
  628          * If metadata pointer doesn't point to a valid address, use hardcoded
  629          * values.
  630          */
  631         physmap_init((mdp != NULL) ? 0 : 1);
  632 
  633         /* Do basic tuning, hz etc */
  634         init_param1();
  635         init_param2(physmem);
  636         kdb_init();
  637         return ((void *)(kernelstack.pv_va + USPACE_SVC_STACK_TOP -
  638             sizeof(struct pcb)));
  639 }
  640 
  641 struct arm32_dma_range *
  642 bus_dma_get_range(void)
  643 {
  644 
  645         return (NULL);
  646 }
  647 
  648 int
  649 bus_dma_get_range_nb(void)
  650 {
  651 
  652         return (0);
  653 }
Cache object: 66683f3a9c05138ba2d5c1229abd914a
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/arm/mv/mv_machdep.c

FreeBSD/Linux Kernel Cross Reference
sys/arm/mv/mv_machdep.c
