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: releng/9.0/sys/mips/mips/machdep.c 224115 2011-07-16 20:31:29Z jchandra $");
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 }
Cache object: b37ed5418f4c6872af9eef2807397705
|