1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <sys/types.h> 27 #include <sys/systm.h> 28 #include <sys/archsystm.h> 29 #include <sys/machsystm.h> 30 #include <sys/disp.h> 31 #include <sys/autoconf.h> 32 #include <sys/promif.h> 33 #include <sys/prom_plat.h> 34 #include <sys/promimpl.h> 35 #include <sys/platform_module.h> 36 #include <sys/clock.h> 37 #include <sys/pte.h> 38 #include <sys/scb.h> 39 #include <sys/cpu.h> 40 #include <sys/stack.h> 41 #include <sys/intreg.h> 42 #include <sys/ivintr.h> 43 #include <vm/as.h> 44 #include <vm/hat_sfmmu.h> 45 #include <sys/reboot.h> 46 #include <sys/sysmacros.h> 47 #include <sys/vtrace.h> 48 #include <sys/trap.h> 49 #include <sys/machtrap.h> 50 #include <sys/privregs.h> 51 #include <sys/machpcb.h> 52 #include <sys/proc.h> 53 #include <sys/cpupart.h> 54 #include <sys/pset.h> 55 #include <sys/cpu_module.h> 56 #include <sys/copyops.h> 57 #include <sys/panic.h> 58 #include <sys/bootconf.h> /* for bootops */ 59 #include <sys/pg.h> 60 #include <sys/kdi.h> 61 #include <sys/fpras.h> 62 63 #include <sys/prom_debug.h> 64 #include <sys/debug.h> 65 66 #include <sys/sunddi.h> 67 #include <sys/lgrp.h> 68 #include <sys/traptrace.h> 69 70 #include <sys/kobj_impl.h> 71 #include <sys/kdi_machimpl.h> 72 73 /* 74 * External Routines: 75 */ 76 extern void map_wellknown_devices(void); 77 extern void hsvc_setup(void); 78 extern void mach_descrip_startup_init(void); 79 extern void mach_soft_state_init(void); 80 81 int dcache_size; 82 int dcache_linesize; 83 int icache_size; 84 int icache_linesize; 85 int ecache_size; 86 int ecache_alignsize; 87 int ecache_associativity; 88 int ecache_setsize; /* max possible e$ setsize */ 89 int cpu_setsize; /* max e$ setsize of configured cpus */ 90 int dcache_line_mask; /* spitfire only */ 91 int vac_size; /* cache size in bytes */ 92 uint_t vac_mask; /* VAC alignment consistency mask */ 93 int vac_shift; /* log2(vac_size) for ppmapout() */ 94 int vac = 0; /* virtual address cache type (none == 0) */ 95 96 /* 97 * fpRAS. An individual sun4* machine class (or perhaps subclass, 98 * eg sun4u/cheetah) must set fpras_implemented to indicate that it implements 99 * the fpRAS feature. The feature can be suppressed by setting fpras_disable 100 * or the mechanism can be disabled for individual copy operations with 101 * fpras_disableids. All these are checked in post_startup() code so 102 * fpras_disable and fpras_disableids can be set in /etc/system. 103 * If/when fpRAS is implemented on non-sun4 architectures these 104 * definitions will need to move up to the common level. 105 */ 106 int fpras_implemented; 107 int fpras_disable; 108 int fpras_disableids; 109 110 /* 111 * Static Routines: 112 */ 113 static void kern_splr_preprom(void); 114 static void kern_splx_postprom(void); 115 116 /* 117 * Setup routine called right before main(). Interposing this function 118 * before main() allows us to call it in a machine-independent fashion. 119 */ 120 121 void 122 mlsetup(struct regs *rp, kfpu_t *fp) 123 { 124 struct machpcb *mpcb; 125 126 extern char t0stack[]; 127 extern struct classfuncs sys_classfuncs; 128 extern disp_t cpu0_disp; 129 unsigned long long pa; 130 131 #ifdef TRAPTRACE 132 TRAP_TRACE_CTL *ctlp; 133 #endif /* TRAPTRACE */ 134 135 /* drop into kmdb on boot -d */ 136 if (boothowto & RB_DEBUGENTER) 137 kmdb_enter(); 138 139 /* 140 * initialize cpu_self 141 */ 142 cpu0.cpu_self = &cpu0; 143 144 /* 145 * initialize t0 146 */ 147 t0.t_stk = (caddr_t)rp - REGOFF; 148 /* Can't use va_to_pa here - wait until prom_ initialized */ 149 t0.t_stkbase = t0stack; 150 t0.t_pri = maxclsyspri - 3; 151 t0.t_schedflag = TS_LOAD | TS_DONT_SWAP; 152 t0.t_procp = &p0; 153 t0.t_plockp = &p0lock.pl_lock; 154 t0.t_lwp = &lwp0; 155 t0.t_forw = &t0; 156 t0.t_back = &t0; 157 t0.t_next = &t0; 158 t0.t_prev = &t0; 159 t0.t_cpu = &cpu0; /* loaded by _start */ 160 t0.t_disp_queue = &cpu0_disp; 161 t0.t_bind_cpu = PBIND_NONE; 162 t0.t_bind_pset = PS_NONE; 163 t0.t_bindflag = (uchar_t)default_binding_mode; 164 t0.t_cpupart = &cp_default; 165 t0.t_clfuncs = &sys_classfuncs.thread; 166 t0.t_copyops = NULL; 167 THREAD_ONPROC(&t0, CPU); 168 169 lwp0.lwp_thread = &t0; 170 lwp0.lwp_procp = &p0; 171 lwp0.lwp_regs = (void *)rp; 172 t0.t_tid = p0.p_lwpcnt = p0.p_lwprcnt = p0.p_lwpid = 1; 173 174 mpcb = lwptompcb(&lwp0); 175 mpcb->mpcb_fpu = fp; 176 mpcb->mpcb_fpu->fpu_q = mpcb->mpcb_fpu_q; 177 mpcb->mpcb_thread = &t0; 178 lwp0.lwp_fpu = (void *)mpcb->mpcb_fpu; 179 180 p0.p_exec = NULL; 181 p0.p_stat = SRUN; 182 p0.p_flag = SSYS; 183 p0.p_tlist = &t0; 184 p0.p_stksize = 2*PAGESIZE; 185 p0.p_stkpageszc = 0; 186 p0.p_as = &kas; 187 p0.p_lockp = &p0lock; 188 p0.p_utraps = NULL; 189 p0.p_brkpageszc = 0; 190 p0.p_t1_lgrpid = LGRP_NONE; 191 p0.p_tr_lgrpid = LGRP_NONE; 192 psecflags_default(&p0.p_secflags); 193 sigorset(&p0.p_ignore, &ignoredefault); 194 195 196 CPU->cpu_thread = &t0; 197 CPU->cpu_dispthread = &t0; 198 bzero(&cpu0_disp, sizeof (disp_t)); 199 CPU->cpu_disp = &cpu0_disp; 200 CPU->cpu_disp->disp_cpu = CPU; 201 CPU->cpu_idle_thread = &t0; 202 CPU->cpu_flags = CPU_RUNNING; 203 CPU->cpu_id = getprocessorid(); 204 CPU->cpu_dispatch_pri = t0.t_pri; 205 206 /* 207 * Initialize thread/cpu microstate accounting 208 */ 209 init_mstate(&t0, LMS_SYSTEM); 210 init_cpu_mstate(CPU, CMS_SYSTEM); 211 212 /* 213 * Initialize lists of available and active CPUs. 214 */ 215 cpu_list_init(CPU); 216 217 cpu_vm_data_init(CPU); 218 219 pg_cpu_bootstrap(CPU); 220 221 (void) prom_set_preprom(kern_splr_preprom); 222 (void) prom_set_postprom(kern_splx_postprom); 223 PRM_INFO("mlsetup: now ok to call prom_printf"); 224 225 mpcb->mpcb_pa = va_to_pa(t0.t_stk); 226 227 /* 228 * Claim the physical and virtual resources used by panicbuf, 229 * then map panicbuf. This operation removes the phys and 230 * virtual addresses from the free lists. 231 */ 232 if (prom_claim_virt(PANICBUFSIZE, panicbuf) != panicbuf) 233 prom_panic("Can't claim panicbuf virtual address"); 234 235 if (prom_retain("panicbuf", PANICBUFSIZE, MMU_PAGESIZE, &pa) != 0) 236 prom_panic("Can't allocate retained panicbuf physical address"); 237 238 if (prom_map_phys(-1, PANICBUFSIZE, panicbuf, pa) != 0) 239 prom_panic("Can't map panicbuf"); 240 241 PRM_DEBUG(panicbuf); 242 PRM_DEBUG(pa); 243 244 /* 245 * Negotiate hypervisor services, if any 246 */ 247 hsvc_setup(); 248 mach_soft_state_init(); 249 250 #ifdef TRAPTRACE 251 /* 252 * initialize the trap trace buffer for the boot cpu 253 * XXX todo, dynamically allocate this buffer too 254 */ 255 ctlp = &trap_trace_ctl[CPU->cpu_id]; 256 ctlp->d.vaddr_base = trap_tr0; 257 ctlp->d.offset = ctlp->d.last_offset = 0; 258 ctlp->d.limit = TRAP_TSIZE; /* XXX dynamic someday */ 259 ctlp->d.paddr_base = va_to_pa(trap_tr0); 260 #endif /* TRAPTRACE */ 261 262 /* 263 * Initialize the Machine Description kernel framework 264 */ 265 266 mach_descrip_startup_init(); 267 268 /* 269 * initialize HV trap trace buffer for the boot cpu 270 */ 271 mach_htraptrace_setup(CPU->cpu_id); 272 mach_htraptrace_configure(CPU->cpu_id); 273 274 /* 275 * lgroup framework initialization. This must be done prior 276 * to devices being mapped. 277 */ 278 lgrp_init(LGRP_INIT_STAGE1); 279 280 cpu_setup(); 281 282 if (boothowto & RB_HALT) { 283 prom_printf("unix: kernel halted by -h flag\n"); 284 prom_enter_mon(); 285 } 286 287 setcputype(); 288 map_wellknown_devices(); 289 setcpudelay(); 290 } 291 292 /* 293 * These routines are called immediately before and 294 * immediately after calling into the firmware. The 295 * firmware is significantly confused by preemption - 296 * particularly on MP machines - but also on UP's too. 297 */ 298 299 static int saved_spl; 300 301 static void 302 kern_splr_preprom(void) 303 { 304 saved_spl = spl7(); 305 } 306 307 static void 308 kern_splx_postprom(void) 309 { 310 splx(saved_spl); 311 } 312 313 314 /* 315 * WARNING 316 * The code fom here to the end of mlsetup.c runs before krtld has 317 * knitted unix and genunix together. It can call routines in unix, 318 * but calls into genunix will fail spectacularly. More specifically, 319 * calls to prom_*, bop_* and str* will work, everything else is 320 * caveat emptor. 321 * 322 * Also note that while #ifdef sun4u is generally a bad idea, they 323 * exist here to concentrate the dangerous code into a single file. 324 */ 325 326 static char * 327 getcpulist(void) 328 { 329 pnode_t node; 330 /* big enough for OBP_NAME and for a reasonably sized OBP_COMPATIBLE. */ 331 static char cpubuf[5 * OBP_MAXDRVNAME]; 332 int nlen, clen, i; 333 #ifdef sun4u 334 char dname[OBP_MAXDRVNAME]; 335 #endif 336 337 node = prom_findnode_bydevtype(prom_rootnode(), OBP_CPU); 338 if (node != OBP_NONODE && node != OBP_BADNODE) { 339 if ((nlen = prom_getproplen(node, OBP_NAME)) <= 0 || 340 nlen > sizeof (cpubuf) || 341 prom_getprop(node, OBP_NAME, cpubuf) <= 0) 342 prom_panic("no name in cpu node"); 343 344 /* nlen includes the terminating null character */ 345 #ifdef sun4v 346 if ((clen = prom_getproplen(node, OBP_COMPATIBLE)) > 0) { 347 #else /* sun4u */ 348 /* 349 * For the CMT case, need check the parent "core" 350 * node for the compatible property. 351 */ 352 if ((clen = prom_getproplen(node, OBP_COMPATIBLE)) > 0 || 353 ((node = prom_parentnode(node)) != OBP_NONODE && 354 node != OBP_BADNODE && 355 (clen = prom_getproplen(node, OBP_COMPATIBLE)) > 0 && 356 prom_getprop(node, OBP_DEVICETYPE, dname) > 0 && 357 strcmp(dname, "core") == 0)) { 358 #endif 359 if ((clen + nlen) > sizeof (cpubuf)) 360 prom_panic("cpu node \"compatible\" too long"); 361 /* read in compatible, leaving space for ':' */ 362 if (prom_getprop(node, OBP_COMPATIBLE, 363 &cpubuf[nlen]) != clen) 364 prom_panic("cpu node \"compatible\" error"); 365 clen += nlen; /* total length */ 366 /* convert all null characters to ':' */ 367 clen--; /* except the final one... */ 368 for (i = 0; i < clen; i++) 369 if (cpubuf[i] == '\0') 370 cpubuf[i] = ':'; 371 } 372 #ifdef sun4u 373 /* 374 * Some PROMs return SUNW,UltraSPARC when they actually have 375 * SUNW,UltraSPARC-II cpus. SInce we're now filtering out all 376 * SUNW,UltraSPARC systems during the boot phase, we can safely 377 * point the auxv CPU value at SUNW,UltraSPARC-II. 378 */ 379 if (strcmp("SUNW,UltraSPARC", cpubuf) == 0) 380 (void) strcpy(cpubuf, "SUNW,UltraSPARC-II"); 381 #endif 382 return (cpubuf); 383 } else 384 return (NULL); 385 } 386 387 /* 388 * called immediately from _start to stich the 389 * primary modules together 390 */ 391 void 392 kobj_start(void *cif) 393 { 394 Ehdr *ehdr; 395 Phdr *phdr; 396 uint32_t eadr, padr; 397 val_t bootaux[BA_NUM]; 398 int i; 399 400 prom_init("kernel", cif); 401 bop_init(); 402 #ifdef DEBUG 403 if (bop_getproplen("stop-me") != -1) 404 prom_enter_mon(); 405 #endif 406 407 if (bop_getprop("elfheader-address", (caddr_t)&eadr) == -1) 408 prom_panic("no ELF image"); 409 ehdr = (Ehdr *)(uintptr_t)eadr; 410 for (i = 0; i < BA_NUM; i++) 411 bootaux[i].ba_val = NULL; 412 bootaux[BA_PHNUM].ba_val = ehdr->e_phnum; 413 bootaux[BA_PHENT].ba_val = ehdr->e_phentsize; 414 bootaux[BA_LDNAME].ba_ptr = NULL; 415 416 padr = eadr + ehdr->e_phoff; 417 bootaux[BA_PHDR].ba_ptr = (void *)(uintptr_t)padr; 418 for (i = 0; i < ehdr->e_phnum; i++) { 419 phdr = (Phdr *)((uintptr_t)padr + i * ehdr->e_phentsize); 420 if (phdr->p_type == PT_DYNAMIC) { 421 bootaux[BA_DYNAMIC].ba_ptr = (void *)phdr->p_vaddr; 422 break; 423 } 424 } 425 426 bootaux[BA_LPAGESZ].ba_val = MMU_PAGESIZE4M; 427 bootaux[BA_PAGESZ].ba_val = MMU_PAGESIZE; 428 bootaux[BA_IFLUSH].ba_val = 1; 429 bootaux[BA_CPU].ba_ptr = getcpulist(); 430 bootaux[BA_MMU].ba_ptr = NULL; 431 432 kobj_init(cif, NULL, bootops, bootaux); 433 434 /* kernel stitched together; we can now test #pragma's */ 435 if (&plat_setprop_enter != NULL) { 436 prom_setprop_enter = &plat_setprop_enter; 437 prom_setprop_exit = &plat_setprop_exit; 438 ASSERT(prom_setprop_exit != NULL); 439 } 440 441 } 442 443 /* 444 * Create modpath from kernel name. 445 * If we booted: 446 * /platform/`uname -i`/kernel/sparcv9/unix 447 * or 448 * /platform/`uname -m`/kernel/sparcv9/unix 449 * 450 * then make the modpath: 451 * /platform/`uname -i`/kernel /platform/`uname -m`/kernel 452 * 453 * otherwise, make the modpath the dir the kernel was 454 * loaded from, minus any sparcv9 extension 455 * 456 * note the sparcv9 dir is optional since a unix -> sparcv9/unix 457 * symlink is available as a shortcut. 458 */ 459 void 460 mach_modpath(char *path, const char *fname) 461 { 462 char *p; 463 int len, compat; 464 const char prefix[] = "/platform/"; 465 char platname[MAXPATHLEN]; 466 #ifdef sun4u 467 char defname[] = "sun4u"; 468 #else 469 char defname[] = "sun4v"; 470 #endif 471 const char suffix[] = "/kernel"; 472 const char isastr[] = "/sparcv9"; 473 474 /* 475 * check for /platform 476 */ 477 p = (char *)fname; 478 if (strncmp(p, prefix, sizeof (prefix) - 1) != 0) 479 goto nopath; 480 p += sizeof (prefix) - 1; 481 482 /* 483 * check for the default name or the platform name. 484 * also see if we used the 'compatible' name 485 * (platname == default) 486 */ 487 (void) bop_getprop("impl-arch-name", platname); 488 compat = strcmp(platname, defname) == 0; 489 len = strlen(platname); 490 if (strncmp(p, platname, len) == 0) 491 p += len; 492 else if (strncmp(p, defname, sizeof (defname) - 1) == 0) 493 p += sizeof (defname) - 1; 494 else 495 goto nopath; 496 497 /* 498 * check for /kernel/sparcv9 or just /kernel 499 */ 500 if (strncmp(p, suffix, sizeof (suffix) - 1) != 0) 501 goto nopath; 502 p += sizeof (suffix) - 1; 503 if (strncmp(p, isastr, sizeof (isastr) - 1) == 0) 504 p += sizeof (isastr) - 1; 505 506 /* 507 * check we're at the last component 508 */ 509 if (p != strrchr(fname, '/')) 510 goto nopath; 511 512 /* 513 * everything is kosher; setup modpath 514 */ 515 (void) strcpy(path, "/platform/"); 516 (void) strcat(path, platname); 517 (void) strcat(path, "/kernel"); 518 if (!compat) { 519 (void) strcat(path, " /platform/"); 520 (void) strcat(path, defname); 521 (void) strcat(path, "/kernel"); 522 } 523 return; 524 525 nopath: 526 /* 527 * Construct the directory path from the filename. 528 */ 529 if ((p = strrchr(fname, '/')) == NULL) 530 return; 531 532 while (p > fname && *(p - 1) == '/') 533 p--; /* remove trailing '/' characters */ 534 if (p == fname) 535 p++; /* so "/" -is- the modpath in this case */ 536 537 /* 538 * Remove optional isa-dependent directory name - the module 539 * subsystem will put this back again (!) 540 */ 541 len = p - fname; 542 if (len > sizeof (isastr) - 1 && 543 strncmp(&fname[len - (sizeof (isastr) - 1)], isastr, 544 sizeof (isastr) - 1) == 0) 545 p -= sizeof (isastr) - 1; 546 (void) strncpy(path, fname, p - fname); 547 } 548