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