1 /* $NetBSD: cpu.h,v 1.67 2007/10/17 19:57:29 garbled Exp $ */ 2 3 /* 4 * Copyright (c) 1992, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This software was developed by the Computer Systems Engineering group 8 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and 9 * contributed to Berkeley. 10 * 11 * All advertising materials mentioning features or use of this software 12 * must display the following acknowledgement: 13 * This product includes software developed by the University of 14 * California, Lawrence Berkeley Laboratory. 15 * 16 * Redistribution and use in source and binary forms, with or without 17 * modification, are permitted provided that the following conditions 18 * are met: 19 * 1. Redistributions of source code must retain the above copyright 20 * notice, this list of conditions and the following disclaimer. 21 * 2. Redistributions in binary form must reproduce the above copyright 22 * notice, this list of conditions and the following disclaimer in the 23 * documentation and/or other materials provided with the distribution. 24 * 3. Neither the name of the University nor the names of its contributors 25 * may be used to endorse or promote products derived from this software 26 * without specific prior written permission. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 31 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 38 * SUCH DAMAGE. 39 * 40 * @(#)cpu.h 8.4 (Berkeley) 1/5/94 41 */ 42 43 #ifndef _CPU_H_ 44 #define _CPU_H_ 45 46 /* 47 * CTL_MACHDEP definitions. 48 */ 49 #define CPU_BOOTED_KERNEL 1 /* string: booted kernel name */ 50 #define CPU_BOOTED_DEVICE 2 /* string: device booted from */ 51 #define CPU_BOOT_ARGS 3 /* string: args booted with */ 52 #define CPU_ARCH 4 /* integer: cpu architecture version */ 53 #define CPU_MAXID 5 /* number of valid machdep ids */ 54 55 #define CTL_MACHDEP_NAMES { \ 56 { 0, 0 }, \ 57 { "booted_kernel", CTLTYPE_STRING }, \ 58 { "booted_device", CTLTYPE_STRING }, \ 59 { "boot_args", CTLTYPE_STRING }, \ 60 { "cpu_arch", CTLTYPE_INT }, \ 61 } 62 63 #ifdef _KERNEL 64 /* 65 * Exported definitions unique to SPARC cpu support. 66 */ 67 68 #if defined(_KERNEL_OPT) 69 #include "opt_multiprocessor.h" 70 #include "opt_lockdebug.h" 71 #endif 72 73 #include <machine/psl.h> 74 #include <machine/reg.h> 75 #include <machine/intr.h> 76 #include <machine/cpuset.h> 77 #include <sparc64/sparc64/intreg.h> 78 79 #include <sys/cpu_data.h> 80 /* 81 * The cpu_info structure is part of a 64KB structure mapped both the kernel 82 * pmap and a single locked TTE a CPUINFO_VA for that particular processor. 83 * Each processor's cpu_info is accessible at CPUINFO_VA only for that 84 * processor. Other processors can access that through an additional mapping 85 * in the kernel pmap. 86 * 87 * The 64KB page contains: 88 * 89 * cpu_info 90 * interrupt stack (all remaining space) 91 * idle PCB 92 * idle stack (STACKSPACE - sizeof(PCB)) 93 * 32KB TSB 94 */ 95 96 struct cpu_info { 97 98 /* 99 * SPARC cpu_info structures live at two VAs: one global 100 * VA (so each CPU can access any other CPU's cpu_info) 101 * and an alias VA CPUINFO_VA which is the same on each 102 * CPU and maps to that CPU's cpu_info. Since the alias 103 * CPUINFO_VA is how we locate our cpu_info, we have to 104 * self-reference the global VA so that we can return it 105 * in the curcpu() macro. 106 */ 107 struct cpu_info * volatile ci_self; 108 109 /* Most important fields first */ 110 struct lwp *ci_curlwp; 111 struct pcb *ci_cpcb; 112 struct cpu_info *ci_next; 113 114 struct lwp *ci_fplwp; 115 116 void *ci_eintstack; 117 118 int ci_mtx_count; 119 int ci_mtx_oldspl; 120 121 /* Spinning up the CPU */ 122 void (*ci_spinup)(void); 123 paddr_t ci_paddr; 124 125 int ci_cpuid; 126 127 /* CPU PROM information. */ 128 u_int ci_node; 129 130 /* %tick and cpu frequency information */ 131 u_long ci_tick_increment; 132 uint64_t ci_cpu_clockrate[2]; 133 134 int ci_flags; 135 int ci_want_ast; 136 int ci_want_resched; 137 138 struct cpu_data ci_data; /* MI per-cpu data */ 139 140 volatile void *ci_ddb_regs; /* DDB regs */ 141 }; 142 143 #define CPUF_PRIMARY 1 144 145 /* 146 * CPU boot arguments. Used by secondary CPUs at the bootstrap time. 147 */ 148 struct cpu_bootargs { 149 u_int cb_node; /* PROM CPU node */ 150 volatile int cb_flags; 151 152 vaddr_t cb_ktext; 153 paddr_t cb_ktextp; 154 vaddr_t cb_ektext; 155 156 vaddr_t cb_kdata; 157 paddr_t cb_kdatap; 158 vaddr_t cb_ekdata; 159 160 paddr_t cb_cpuinfo; 161 }; 162 163 extern struct cpu_bootargs *cpu_args; 164 165 extern int sparc_ncpus; 166 extern struct cpu_info *cpus; 167 168 #define curcpu() (((struct cpu_info *)CPUINFO_VA)->ci_self) 169 #define cpu_number() (curcpu()->ci_index) 170 #define CPU_IS_PRIMARY(ci) ((ci)->ci_flags & CPUF_PRIMARY) 171 172 #define CPU_INFO_ITERATOR int 173 #define CPU_INFO_FOREACH(cii, ci) cii = 0, ci = cpus; ci != NULL; \ 174 ci = ci->ci_next 175 176 #define curlwp curcpu()->ci_curlwp 177 #define fplwp curcpu()->ci_fplwp 178 #define curpcb curcpu()->ci_cpcb 179 180 #define want_ast curcpu()->ci_want_ast 181 #define want_resched curcpu()->ci_want_resched 182 183 /* 184 * definitions of cpu-dependent requirements 185 * referenced in generic code 186 */ 187 #define cpu_swapin(p) /* nothing */ 188 #define cpu_swapout(p) /* nothing */ 189 #define cpu_wait(p) /* nothing */ 190 void cpu_proc_fork(struct proc *, struct proc *); 191 192 #if defined(MULTIPROCESSOR) 193 extern vaddr_t cpu_spinup_trampoline; 194 195 extern char *mp_tramp_code; 196 extern u_long mp_tramp_code_len; 197 extern u_long mp_tramp_tlb_slots; 198 extern u_long mp_tramp_func; 199 extern u_long mp_tramp_ci; 200 201 void cpu_hatch(void); 202 void cpu_boot_secondary_processors(void); 203 204 /* 205 * Call a function on other cpus: 206 * multicast - send to everyone in the cpuset_t 207 * broadcast - send to to all cpus but ourselves 208 * send - send to just this cpu 209 */ 210 typedef void (* ipifunc_t)(void *); 211 212 void sparc64_multicast_ipi (cpuset_t, ipifunc_t); 213 void sparc64_broadcast_ipi (ipifunc_t); 214 void sparc64_send_ipi (int, ipifunc_t); 215 #endif 216 217 /* 218 * Arguments to hardclock, softclock and gatherstats encapsulate the 219 * previous machine state in an opaque clockframe. The ipl is here 220 * as well for strayintr (see locore.s:interrupt and intr.c:strayintr). 221 * Note that CLKF_INTR is valid only if CLKF_USERMODE is false. 222 */ 223 extern int intstack[]; 224 extern int eintstack[]; 225 struct clockframe { 226 struct trapframe64 t; 227 }; 228 229 #define CLKF_USERMODE(framep) (((framep)->t.tf_tstate & TSTATE_PRIV) == 0) 230 #define CLKF_PC(framep) ((framep)->t.tf_pc) 231 /* Since some files in sys/kern do not know BIAS, I'm using 0x7ff here */ 232 #define CLKF_INTR(framep) \ 233 ((!CLKF_USERMODE(framep))&& \ 234 (((framep)->t.tf_out[6] & 1 ) ? \ 235 (((vaddr_t)(framep)->t.tf_out[6] < \ 236 (vaddr_t)EINTSTACK-0x7ff) && \ 237 ((vaddr_t)(framep)->t.tf_out[6] > \ 238 (vaddr_t)INTSTACK-0x7ff)) : \ 239 (((vaddr_t)(framep)->t.tf_out[6] < \ 240 (vaddr_t)EINTSTACK) && \ 241 ((vaddr_t)(framep)->t.tf_out[6] > \ 242 (vaddr_t)INTSTACK)))) 243 244 245 extern struct intrhand soft01intr, soft01net, soft01clock; 246 247 void setsoftint(void); 248 void setsoftnet(void); 249 250 /* 251 * Give a profiling tick to the current process when the user profiling 252 * buffer pages are invalid. On the sparc, request an ast to send us 253 * through trap(), marking the proc as needing a profiling tick. 254 */ 255 #define cpu_need_proftick(l) ((l)->l_pflag |= LP_OWEUPC, want_ast = 1) 256 257 /* 258 * Notify the current process (l) that it has a signal pending, 259 * process as soon as possible. 260 */ 261 #define cpu_signotify(l) (want_ast = 1) 262 263 /* 264 * Interrupt handler chains. Interrupt handlers should return 0 for 265 * ``not me'' or 1 (``I took care of it''). intr_establish() inserts a 266 * handler into the list. The handler is called with its (single) 267 * argument, or with a pointer to a clockframe if ih_arg is NULL. 268 */ 269 struct intrhand { 270 int (*ih_fun)(void *); 271 void *ih_arg; 272 short ih_number; /* interrupt number */ 273 /* the H/W provides */ 274 char ih_pil; /* interrupt priority */ 275 struct intrhand *ih_next; /* global list */ 276 struct intrhand *ih_pending; /* interrupt queued */ 277 volatile uint64_t *ih_map; /* Interrupt map reg */ 278 volatile uint64_t *ih_clr; /* clear interrupt reg */ 279 }; 280 extern struct intrhand *intrhand[]; 281 extern struct intrhand *intrlev[MAXINTNUM]; 282 283 void intr_establish(int level, struct intrhand *); 284 285 /* disksubr.c */ 286 struct dkbad; 287 int isbad(struct dkbad *bt, int, int, int); 288 /* machdep.c */ 289 void * reserve_dumppages(void *); 290 /* clock.c */ 291 struct timeval; 292 int tickintr(void *); /* level 10 (tick) interrupt code */ 293 int clockintr(void *); /* level 10 (clock) interrupt code */ 294 int statintr(void *); /* level 14 (statclock) interrupt code */ 295 /* locore.s */ 296 struct fpstate64; 297 void savefpstate(struct fpstate64 *); 298 void loadfpstate(struct fpstate64 *); 299 void clearfpstate(void); 300 uint64_t probeget(paddr_t, int, int); 301 int probeset(paddr_t, int, int, uint64_t); 302 303 #define write_all_windows() __asm volatile("flushw" : : ) 304 #define write_user_windows() __asm volatile("flushw" : : ) 305 306 void lwp_trampoline(void); 307 struct pcb; 308 void snapshot(struct pcb *); 309 struct frame *getfp(void); 310 void switchtoctx(int); 311 /* trap.c */ 312 void kill_user_windows(struct lwp *); 313 int rwindow_save(struct lwp *); 314 /* cons.c */ 315 int cnrom(void); 316 /* zs.c */ 317 void zsconsole(struct tty *, int, int, void (**)(struct tty *, int)); 318 /* fb.c */ 319 void fb_unblank(void); 320 /* kgdb_stub.c */ 321 #ifdef KGDB 322 void kgdb_attach(int (*)(void *), void (*)(void *, int), void *); 323 void kgdb_connect(int); 324 void kgdb_panic(void); 325 #endif 326 /* emul.c */ 327 int fixalign(struct lwp *, struct trapframe64 *); 328 int emulinstr(vaddr_t, struct trapframe64 *); 329 330 #endif /* _KERNEL */ 331 #endif /* _CPU_H_ */ 332