sys/mips/mips/machdep.c

   1     /*  $OpenBSD: machdep.c,v 1.33 1998/09/15 10:58:54 pefo Exp $       */
   2 /* tracked to 1.38 */
   3 /*
   4  * Copyright (c) 1988 University of Utah.
   5  * Copyright (c) 1992, 1993
   6  *      The Regents of the University of California.  All rights reserved.
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * the Systems Programming Group of the University of Utah Computer
  10  * Science Department, The Mach Operating System project at
  11  * Carnegie-Mellon University and Ralph Campbell.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 4. Neither the name of the University nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  *
  37  *      from: @(#)machdep.c     8.3 (Berkeley) 1/12/94
  38  *      Id: machdep.c,v 1.33 1998/09/15 10:58:54 pefo Exp
  39  *      JNPR: machdep.c,v 1.11.2.3 2007/08/29 12:24:49
  40  */
  41
  42 #include <sys/cdefs.h>
  43 __FBSDID("$FreeBSD$");
  44
  45 #include "opt_cputype.h"
  46 #include "opt_ddb.h"
  47 #include "opt_md.h"
  48
  49 #include <sys/param.h>
  50 #include <sys/proc.h>
  51 #include <sys/systm.h>
  52 #include <sys/buf.h>
  53 #include <sys/bus.h>
  54 #include <sys/conf.h>
  55 #include <sys/cpu.h>
  56 #include <sys/kernel.h>
  57 #include <sys/linker.h>
  58 #include <sys/malloc.h>
  59 #include <sys/mbuf.h>
  60 #include <sys/msgbuf.h>
  61 #include <sys/reboot.h>
  62 #include <sys/sched.h>
  63 #include <sys/sysctl.h>
  64 #include <sys/sysproto.h>
  65 #include <sys/vmmeter.h>
  66
  67 #include <vm/vm.h>
  68 #include <vm/vm_kern.h>
  69 #include <vm/vm_object.h>
  70 #include <vm/vm_page.h>
  71 #include <vm/pmap.h>
  72 #include <vm/vm_map.h>
  73 #include <vm/vm_pager.h>
  74 #include <vm/vm_extern.h>
  75 #include <sys/socket.h>
  76
  77 #include <sys/user.h>
  78 #include <sys/interrupt.h>
  79 #include <sys/cons.h>
  80 #include <sys/syslog.h>
  81 #include <machine/asm.h>
  82 #include <machine/bootinfo.h>
  83 #include <machine/cache.h>
  84 #include <machine/clock.h>
  85 #include <machine/cpu.h>
  86 #include <machine/cpuregs.h>
  87 #include <machine/elf.h>
  88 #include <machine/hwfunc.h>
  89 #include <machine/intr_machdep.h>
  90 #include <machine/md_var.h>
  91 #include <machine/tlb.h>
  92 #ifdef DDB
  93 #include <sys/kdb.h>
  94 #include <ddb/ddb.h>
  95 #endif
  96
  97 #include <sys/random.h>
  98 #include <net/if.h>
  99
 100 #define BOOTINFO_DEBUG  0
 101
 102 char machine[] = "mips";
 103 SYSCTL_STRING(_hw, HW_MACHINE, machine, CTLFLAG_RD, machine, 0, "Machine class");
 104
 105 char cpu_model[80];
 106 SYSCTL_STRING(_hw, HW_MODEL, model, CTLFLAG_RD, cpu_model, 0, "Machine model");
 107
 108 char cpu_board[80];
 109 SYSCTL_STRING(_hw, OID_AUTO, board, CTLFLAG_RD, cpu_board, 0, "Machine board");
 110
 111 int cold = 1;
 112 long realmem = 0;
 113 long Maxmem = 0;
 114 int cpu_clock = MIPS_DEFAULT_HZ;
 115 SYSCTL_INT(_hw, OID_AUTO, clockrate, CTLFLAG_RD,
 116     &cpu_clock, 0, "CPU instruction clock rate");
 117 int clocks_running = 0;
 118
 119 vm_offset_t kstack0;
 120
 121 /*
 122  * Each entry in the pcpu_space[] array is laid out in the following manner:
 123  * struct pcpu for cpu 'n'      pcpu_space[n]
 124  * boot stack for cpu 'n'       pcpu_space[n] + PAGE_SIZE * 2 - CALLFRAME_SIZ
 125  *
 126  * Note that the boot stack grows downwards and we assume that we never
 127  * use enough stack space to trample over the 'struct pcpu' that is at
 128  * the beginning of the array.
 129  *
 130  * The array is aligned on a (PAGE_SIZE * 2) boundary so that the 'struct pcpu'
 131  * is always in the even page frame of the wired TLB entry on SMP kernels.
 132  *
 133  * The array is in the .data section so that the stack does not get zeroed out
 134  * when the .bss section is zeroed.
 135  */
 136 char pcpu_space[MAXCPU][PAGE_SIZE * 2] \
 137         __aligned(PAGE_SIZE * 2) __section(".data");
 138
 139 struct pcpu *pcpup = (struct pcpu *)pcpu_space;
 140
 141 vm_paddr_t phys_avail[PHYS_AVAIL_ENTRIES + 2];
 142 vm_paddr_t physmem_desc[PHYS_AVAIL_ENTRIES + 2];
 143 vm_paddr_t dump_avail[PHYS_AVAIL_ENTRIES + 2];
 144
 145 #ifdef UNIMPLEMENTED
 146 struct platform platform;
 147 #endif
 148
 149 static void cpu_startup(void *);
 150 SYSINIT(cpu, SI_SUB_CPU, SI_ORDER_FIRST, cpu_startup, NULL);
 151
 152 struct kva_md_info kmi;
 153
 154 int cpucfg;                     /* Value of processor config register */
 155 int num_tlbentries = 64;        /* Size of the CPU tlb */
 156 int cputype;
 157
 158 extern char MipsException[], MipsExceptionEnd[];
 159
 160 /* TLB miss handler address and end */
 161 extern char MipsTLBMiss[], MipsTLBMissEnd[];
 162
 163 /* Cache error handler */
 164 extern char MipsCache[], MipsCacheEnd[];
 165
 166 extern char edata[], end[];
 167 #ifdef DDB
 168 extern vm_offset_t ksym_start, ksym_end;
 169 #endif
 170
 171 u_int32_t bootdev;
 172 struct bootinfo bootinfo;
 173 /*
 174  * First kseg0 address available for use. By default it's equal to &end.
 175  * But in some cases there might be additional data placed right after
 176  * _end by loader or ELF trampoline.
 177  */
 178 vm_offset_t kernel_kseg0_end = (vm_offset_t)&end;
 179
 180 static void
 181 cpu_startup(void *dummy)
 182 {
 183
 184         if (boothowto & RB_VERBOSE)
 185                 bootverbose++;
 186
 187         printf("real memory  = %ju (%juK bytes)\n", ptoa((uintmax_t)realmem),
 188             ptoa((uintmax_t)realmem) / 1024);
 189
 190         /*
 191          * Display any holes after the first chunk of extended memory.
 192          */
 193         if (bootverbose) {
 194                 int indx;
 195
 196                 printf("Physical memory chunk(s):\n");
 197                 for (indx = 0; phys_avail[indx + 1] != 0; indx += 2) {
 198                         vm_paddr_t size1 = phys_avail[indx + 1] - phys_avail[indx];
 199
 200                         printf("0x%08jx - 0x%08jx, %ju bytes (%ju pages)\n",
 201                             (uintmax_t)phys_avail[indx],
 202                             (uintmax_t)phys_avail[indx + 1] - 1,
 203                             (uintmax_t)size1,
 204                             (uintmax_t)size1 / PAGE_SIZE);
 205                 }
 206         }
 207
 208         vm_ksubmap_init(&kmi);
 209
 210         printf("avail memory = %ju (%juMB)\n",
 211             ptoa((uintmax_t)cnt.v_free_count),
 212             ptoa((uintmax_t)cnt.v_free_count) / 1048576);
 213         cpu_init_interrupts();
 214
 215         /*
 216          * Set up buffers, so they can be used to read disk labels.
 217          */
 218         bufinit();
 219         vm_pager_bufferinit();
 220 }
 221
 222 /*
 223  * Shutdown the CPU as much as possible
 224  */
 225 void
 226 cpu_reset(void)
 227 {
 228
 229         platform_reset();
 230 }
 231
 232 /*
 233  * Flush the D-cache for non-DMA I/O so that the I-cache can
 234  * be made coherent later.
 235  */
 236 void
 237 cpu_flush_dcache(void *ptr, size_t len)
 238 {
 239         /* TBD */
 240 }
 241
 242 /* Get current clock frequency for the given cpu id. */
 243 int
 244 cpu_est_clockrate(int cpu_id, uint64_t *rate)
 245 {
 246
 247         return (ENXIO);
 248 }
 249
 250 /*
 251  * Shutdown the CPU as much as possible
 252  */
 253 void
 254 cpu_halt(void)
 255 {
 256         for (;;)
 257                 ;
 258 }
 259
 260 SYSCTL_STRUCT(_machdep, OID_AUTO, bootinfo, CTLFLAG_RD, &bootinfo,
 261     bootinfo, "Bootinfo struct: kernel filename, BIOS harddisk geometry, etc");
 262
 263 /*
 264  * Initialize per cpu data structures, include curthread.
 265  */
 266 void
 267 mips_pcpu0_init()
 268 {
 269         /* Initialize pcpu info of cpu-zero */
 270         pcpu_init(PCPU_ADDR(0), 0, sizeof(struct pcpu));
 271         PCPU_SET(curthread, &thread0);
 272 }
 273
 274 /*
 275  * Initialize mips and configure to run kernel
 276  */
 277 void
 278 mips_proc0_init(void)
 279 {
 280 #ifdef SMP
 281         if (platform_processor_id() != 0)
 282                 panic("BSP must be processor number 0");
 283 #endif
 284         proc_linkup0(&proc0, &thread0);
 285
 286         KASSERT((kstack0 & PAGE_MASK) == 0,
 287                 ("kstack0 is not aligned on a page boundary: 0x%0lx",
 288                 (long)kstack0));
 289         thread0.td_kstack = kstack0;
 290         thread0.td_kstack_pages = KSTACK_PAGES;
 291         /*
 292          * Do not use cpu_thread_alloc to initialize these fields
 293          * thread0 is the only thread that has kstack located in KSEG0
 294          * while cpu_thread_alloc handles kstack allocated in KSEG2.
 295          */
 296         thread0.td_pcb = (struct pcb *)(thread0.td_kstack +
 297             thread0.td_kstack_pages * PAGE_SIZE) - 1;
 298         thread0.td_frame = &thread0.td_pcb->pcb_regs;
 299
 300         /* Steal memory for the dynamic per-cpu area. */
 301         dpcpu_init((void *)pmap_steal_memory(DPCPU_SIZE), 0);
 302
 303         PCPU_SET(curpcb, thread0.td_pcb);
 304         /*
 305          * There is no need to initialize md_upte array for thread0 as it's
 306          * located in .bss section and should be explicitly zeroed during
 307          * kernel initialization.
 308          */
 309 }
 310
 311 void
 312 cpu_initclocks(void)
 313 {
 314
 315         platform_initclocks();
 316         cpu_initclocks_bsp();
 317 }
 318
 319 struct msgbuf *msgbufp=0;
 320
 321 /*
 322  * Initialize the hardware exception vectors, and the jump table used to
 323  * call locore cache and TLB management functions, based on the kind
 324  * of CPU the kernel is running on.
 325  */
 326 void
 327 mips_vector_init(void)
 328 {
 329         /*
 330          * Copy down exception vector code.
 331          */
 332         if (MipsTLBMissEnd - MipsTLBMiss > 0x80)
 333                 panic("startup: UTLB code too large");
 334
 335         if (MipsCacheEnd - MipsCache > 0x80)
 336                 panic("startup: Cache error code too large");
 337
 338         bcopy(MipsTLBMiss, (void *)MIPS_UTLB_MISS_EXC_VEC,
 339               MipsTLBMissEnd - MipsTLBMiss);
 340
 341 #if defined(CPU_CNMIPS) || defined(CPU_RMI) || defined(CPU_NLM)
 342 /* Fake, but sufficient, for the 32-bit with 64-bit hardware addresses  */
 343         bcopy(MipsTLBMiss, (void *)MIPS3_XTLB_MISS_EXC_VEC,
 344               MipsTLBMissEnd - MipsTLBMiss);
 345 #endif
 346
 347         bcopy(MipsException, (void *)MIPS3_GEN_EXC_VEC,
 348               MipsExceptionEnd - MipsException);
 349
 350         bcopy(MipsCache, (void *)MIPS3_CACHE_ERR_EXC_VEC,
 351               MipsCacheEnd - MipsCache);
 352
 353         /*
 354          * Clear out the I and D caches.
 355          */
 356         mips_icache_sync_all();
 357         mips_dcache_wbinv_all();
 358
 359         /*
 360          * Mask all interrupts. Each interrupt will be enabled
 361          * when handler is installed for it
 362          */
 363         set_intr_mask(0);
 364
 365         /* Clear BEV in SR so we start handling our own exceptions */
 366         mips_wr_status(mips_rd_status() & ~MIPS_SR_BEV);
 367 }
 368
 369 /*
 370  * Fix kernel_kseg0_end address in case trampoline placed debug sympols
 371  * data there
 372  */
 373 void
 374 mips_postboot_fixup(void)
 375 {
 376 #ifdef DDB
 377         Elf_Size *trampoline_data = (Elf_Size*)kernel_kseg0_end;
 378         Elf_Size symtabsize = 0;
 379
 380         if (trampoline_data[0] == SYMTAB_MAGIC) {
 381                 symtabsize = trampoline_data[1];
 382                 kernel_kseg0_end += 2 * sizeof(Elf_Size);
 383                 /* start of .symtab */
 384                 ksym_start = kernel_kseg0_end;
 385                 kernel_kseg0_end += symtabsize;
 386                 /* end of .strtab */
 387                 ksym_end = kernel_kseg0_end;
 388         }
 389 #endif
 390 }
 391
 392 /*
 393  * Many SoCs have a means to reset the core itself.  Others do not, or
 394  * the method is unknown to us.  For those cases, we jump to the mips
 395  * reset vector and hope for the best.  This works well in practice.
 396  */
 397 void
 398 mips_generic_reset()
 399 {
 400         ((void(*)(void))(intptr_t)MIPS_VEC_RESET)();
 401 }
 402
 403 #ifdef SMP
 404 void
 405 mips_pcpu_tlb_init(struct pcpu *pcpu)
 406 {
 407         vm_paddr_t pa;
 408         pt_entry_t pte;
 409
 410         /*
 411          * Map the pcpu structure at the virtual address 'pcpup'.
 412          * We use a wired tlb index to do this one-time mapping.
 413          */
 414         pa = vtophys(pcpu);
 415         pte = PTE_D | PTE_V | PTE_G | PTE_C_CACHE;
 416         tlb_insert_wired(PCPU_TLB_ENTRY, (vm_offset_t)pcpup,
 417                          TLBLO_PA_TO_PFN(pa) | pte,
 418                          TLBLO_PA_TO_PFN(pa + PAGE_SIZE) | pte);
 419 }
 420 #endif
 421
 422 /*
 423  * Initialise a struct pcpu.
 424  */
 425 void
 426 cpu_pcpu_init(struct pcpu *pcpu, int cpuid, size_t size)
 427 {
 428
 429         pcpu->pc_next_asid = 1;
 430         pcpu->pc_asid_generation = 1;
 431 #ifdef SMP
 432         if ((vm_offset_t)pcpup >= VM_MIN_KERNEL_ADDRESS &&
 433             (vm_offset_t)pcpup <= VM_MAX_KERNEL_ADDRESS) {
 434                 mips_pcpu_tlb_init(pcpu);
 435         }
 436 #endif
 437 }
 438
 439 int
 440 fill_dbregs(struct thread *td, struct dbreg *dbregs)
 441 {
 442
 443         /* No debug registers on mips */
 444         return (ENOSYS);
 445 }
 446
 447 int
 448 set_dbregs(struct thread *td, struct dbreg *dbregs)
 449 {
 450
 451         /* No debug registers on mips */
 452         return (ENOSYS);
 453 }
 454
 455 void
 456 spinlock_enter(void)
 457 {
 458         struct thread *td;
 459         register_t intr;
 460
 461         td = curthread;
 462         if (td->td_md.md_spinlock_count == 0) {
 463                 intr = intr_disable();
 464                 td->td_md.md_spinlock_count = 1;
 465                 td->td_md.md_saved_intr = intr;
 466         } else
 467                 td->td_md.md_spinlock_count++;
 468         critical_enter();
 469 }
 470
 471 void
 472 spinlock_exit(void)
 473 {
 474         struct thread *td;
 475         register_t intr;
 476
 477         td = curthread;
 478         critical_exit();
 479         intr = td->td_md.md_saved_intr;
 480         td->td_md.md_spinlock_count--;
 481         if (td->td_md.md_spinlock_count == 0)
 482                 intr_restore(intr);
 483 }
 484
 485 /*
 486  * call platform specific code to halt (until next interrupt) for the idle loop
 487  */
 488 void
 489 cpu_idle(int busy)
 490 {
 491         KASSERT((mips_rd_status() & MIPS_SR_INT_IE) != 0,
 492                 ("interrupts disabled in idle process."));
 493         KASSERT((mips_rd_status() & MIPS_INT_MASK) != 0,
 494                 ("all interrupts masked in idle process."));
 495
 496         if (!busy) {
 497                 critical_enter();
 498                 cpu_idleclock();
 499         }
 500         __asm __volatile ("wait");
 501         if (!busy) {
 502                 cpu_activeclock();
 503                 critical_exit();
 504         }
 505 }
 506
 507 int
 508 cpu_idle_wakeup(int cpu)
 509 {
 510
 511         return (0);
 512 }
 513
 514 int
 515 is_cacheable_mem(vm_paddr_t pa)
 516 {
 517         int i;
 518
 519         for (i = 0; physmem_desc[i + 1] != 0; i += 2) {
 520                 if (pa >= physmem_desc[i] && pa < physmem_desc[i + 1])
 521                         return (1);
 522         }
 523
 524         return (0);
 525 }