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 sigorset(&p0.p_ignore, &ignoredefault); 193 194 CPU->cpu_thread = &t0; 195 CPU->cpu_dispthread = &t0; 196 bzero(&cpu0_disp, sizeof (disp_t)); 197 CPU->cpu_disp = &cpu0_disp; 198 CPU->cpu_disp->disp_cpu = CPU; 199 CPU->cpu_idle_thread = &t0; 200 CPU->cpu_flags = CPU_RUNNING; 201 CPU->cpu_id = getprocessorid(); 202 CPU->cpu_dispatch_pri = t0.t_pri; 203 204 /* 205 * Initialize thread/cpu microstate accounting 206 */ 207 init_mstate(&t0, LMS_SYSTEM); 208 init_cpu_mstate(CPU, CMS_SYSTEM); 209 210 /* 211 * Initialize lists of available and active CPUs. 212 */ 213 cpu_list_init(CPU); 214 215 cpu_vm_data_init(CPU); 216 217 pg_cpu_bootstrap(CPU); 218 219 (void) prom_set_preprom(kern_splr_preprom); 220 (void) prom_set_postprom(kern_splx_postprom); 221 PRM_INFO("mlsetup: now ok to call prom_printf"); 222 223 mpcb->mpcb_pa = va_to_pa(t0.t_stk); 224 225 /* 226 * Claim the physical and virtual resources used by panicbuf, 227 * then map panicbuf. This operation removes the phys and 228 * virtual addresses from the free lists. 229 */ 230 if (prom_claim_virt(PANICBUFSIZE, panicbuf) != panicbuf) 231 prom_panic("Can't claim panicbuf virtual address"); 232 233 if (prom_retain("panicbuf", PANICBUFSIZE, MMU_PAGESIZE, &pa) != 0) 234 prom_panic("Can't allocate retained panicbuf physical address"); 235 236 if (prom_map_phys(-1, PANICBUFSIZE, panicbuf, pa) != 0) 237 prom_panic("Can't map panicbuf"); 238 239 PRM_DEBUG(panicbuf); 240 PRM_DEBUG(pa); 241 242 /* 243 * Negotiate hypervisor services, if any 244 */ 245 hsvc_setup(); 246 mach_soft_state_init(); 247 248 #ifdef TRAPTRACE 249 /* 250 * initialize the trap trace buffer for the boot cpu 251 * XXX todo, dynamically allocate this buffer too 252 */ 253 ctlp = &trap_trace_ctl[CPU->cpu_id]; 254 ctlp->d.vaddr_base = trap_tr0; 255 ctlp->d.offset = ctlp->d.last_offset = 0; 256 ctlp->d.limit = TRAP_TSIZE; /* XXX dynamic someday */ 257 ctlp->d.paddr_base = va_to_pa(trap_tr0); 258 #endif /* TRAPTRACE */ 259 260 /* 261 * Initialize the Machine Description kernel framework 262 */ 263 264 mach_descrip_startup_init(); 265 266 /* 267 * initialize HV trap trace buffer for the boot cpu 268 */ 269 mach_htraptrace_setup(CPU->cpu_id); 270 mach_htraptrace_configure(CPU->cpu_id); 271 272 /* 273 * lgroup framework initialization. This must be done prior 274 * to devices being mapped. 275 */ 276 lgrp_init(LGRP_INIT_STAGE1); 277 278 cpu_setup(); 279 280 if (boothowto & RB_HALT) { 281 prom_printf("unix: kernel halted by -h flag\n"); 282 prom_enter_mon(); 283 } 284 285 setcputype(); 286 map_wellknown_devices(); 287 setcpudelay(); 288 } 289 290 /* 291 * These routines are called immediately before and 292 * immediately after calling into the firmware. The 293 * firmware is significantly confused by preemption - 294 * particularly on MP machines - but also on UP's too. 295 */ 296 297 static int saved_spl; 298 299 static void 300 kern_splr_preprom(void) 301 { 302 saved_spl = spl7(); 303 } 304 305 static void 306 kern_splx_postprom(void) 307 { 308 splx(saved_spl); 309 } 310 311 312 /* 313 * WARNING 314 * The code fom here to the end of mlsetup.c runs before krtld has 315 * knitted unix and genunix together. It can call routines in unix, 316 * but calls into genunix will fail spectacularly. More specifically, 317 * calls to prom_*, bop_* and str* will work, everything else is 318 * caveat emptor. 319 * 320 * Also note that while #ifdef sun4u is generally a bad idea, they 321 * exist here to concentrate the dangerous code into a single file. 322 */ 323 324 static char * 325 getcpulist(void) 326 { 327 pnode_t node; 328 /* big enough for OBP_NAME and for a reasonably sized OBP_COMPATIBLE. */ 329 static char cpubuf[5 * OBP_MAXDRVNAME]; 330 int nlen, clen, i; 331 #ifdef sun4u 332 char dname[OBP_MAXDRVNAME]; 333 #endif 334 335 node = prom_findnode_bydevtype(prom_rootnode(), OBP_CPU); 336 if (node != OBP_NONODE && node != OBP_BADNODE) { 337 if ((nlen = prom_getproplen(node, OBP_NAME)) <= 0 || 338 nlen > sizeof (cpubuf) || 339 prom_getprop(node, OBP_NAME, cpubuf) <= 0) 340 prom_panic("no name in cpu node"); 341 342 /* nlen includes the terminating null character */ 343 #ifdef sun4v 344 if ((clen = prom_getproplen(node, OBP_COMPATIBLE)) > 0) { 345 #else /* sun4u */ 346 /* 347 * For the CMT case, need check the parent "core" 348 * node for the compatible property. 349 */ 350 if ((clen = prom_getproplen(node, OBP_COMPATIBLE)) > 0 || 351 ((node = prom_parentnode(node)) != OBP_NONODE && 352 node != OBP_BADNODE && 353 (clen = prom_getproplen(node, OBP_COMPATIBLE)) > 0 && 354 prom_getprop(node, OBP_DEVICETYPE, dname) > 0 && 355 strcmp(dname, "core") == 0)) { 356 #endif 357 if ((clen + nlen) > sizeof (cpubuf)) 358 prom_panic("cpu node \"compatible\" too long"); 359 /* read in compatible, leaving space for ':' */ 360 if (prom_getprop(node, OBP_COMPATIBLE, 361 &cpubuf[nlen]) != clen) 362 prom_panic("cpu node \"compatible\" error"); 363 clen += nlen; /* total length */ 364 /* convert all null characters to ':' */ 365 clen--; /* except the final one... */ 366 for (i = 0; i < clen; i++) 367 if (cpubuf[i] == '\0') 368 cpubuf[i] = ':'; 369 } 370 #ifdef sun4u 371 /* 372 * Some PROMs return SUNW,UltraSPARC when they actually have 373 * SUNW,UltraSPARC-II cpus. SInce we're now filtering out all 374 * SUNW,UltraSPARC systems during the boot phase, we can safely 375 * point the auxv CPU value at SUNW,UltraSPARC-II. 376 */ 377 if (strcmp("SUNW,UltraSPARC", cpubuf) == 0) 378 (void) strcpy(cpubuf, "SUNW,UltraSPARC-II"); 379 #endif 380 return (cpubuf); 381 } else 382 return (NULL); 383 } 384 385 /* 386 * called immediately from _start to stich the 387 * primary modules together 388 */ 389 void 390 kobj_start(void *cif) 391 { 392 Ehdr *ehdr; 393 Phdr *phdr; 394 uint32_t eadr, padr; 395 val_t bootaux[BA_NUM]; 396 int i; 397 398 prom_init("kernel", cif); 399 bop_init(); 400 #ifdef DEBUG 401 if (bop_getproplen("stop-me") != -1) 402 prom_enter_mon(); 403 #endif 404 405 if (bop_getprop("elfheader-address", (caddr_t)&eadr) == -1) 406 prom_panic("no ELF image"); 407 ehdr = (Ehdr *)(uintptr_t)eadr; 408 for (i = 0; i < BA_NUM; i++) 409 bootaux[i].ba_val = NULL; 410 bootaux[BA_PHNUM].ba_val = ehdr->e_phnum; 411 bootaux[BA_PHENT].ba_val = ehdr->e_phentsize; 412 bootaux[BA_LDNAME].ba_ptr = NULL; 413 414 padr = eadr + ehdr->e_phoff; 415 bootaux[BA_PHDR].ba_ptr = (void *)(uintptr_t)padr; 416 for (i = 0; i < ehdr->e_phnum; i++) { 417 phdr = (Phdr *)((uintptr_t)padr + i * ehdr->e_phentsize); 418 if (phdr->p_type == PT_DYNAMIC) { 419 bootaux[BA_DYNAMIC].ba_ptr = (void *)phdr->p_vaddr; 420 break; 421 } 422 } 423 424 bootaux[BA_LPAGESZ].ba_val = MMU_PAGESIZE4M; 425 bootaux[BA_PAGESZ].ba_val = MMU_PAGESIZE; 426 bootaux[BA_IFLUSH].ba_val = 1; 427 bootaux[BA_CPU].ba_ptr = getcpulist(); 428 bootaux[BA_MMU].ba_ptr = NULL; 429 430 kobj_init(cif, NULL, bootops, bootaux); 431 432 /* kernel stitched together; we can now test #pragma's */ 433 if (&plat_setprop_enter != NULL) { 434 prom_setprop_enter = &plat_setprop_enter; 435 prom_setprop_exit = &plat_setprop_exit; 436 ASSERT(prom_setprop_exit != NULL); 437 } 438 439 } 440 441 /* 442 * Create modpath from kernel name. 443 * If we booted: 444 * /platform/`uname -i`/kernel/sparcv9/unix 445 * or 446 * /platform/`uname -m`/kernel/sparcv9/unix 447 * 448 * then make the modpath: 449 * /platform/`uname -i`/kernel /platform/`uname -m`/kernel 450 * 451 * otherwise, make the modpath the dir the kernel was 452 * loaded from, minus any sparcv9 extension 453 * 454 * note the sparcv9 dir is optional since a unix -> sparcv9/unix 455 * symlink is available as a shortcut. 456 */ 457 void 458 mach_modpath(char *path, const char *fname) 459 { 460 char *p; 461 int len, compat; 462 const char prefix[] = "/platform/"; 463 char platname[MAXPATHLEN]; 464 #ifdef sun4u 465 char defname[] = "sun4u"; 466 #else 467 char defname[] = "sun4v"; 468 #endif 469 const char suffix[] = "/kernel"; 470 const char isastr[] = "/sparcv9"; 471 472 /* 473 * check for /platform 474 */ 475 p = (char *)fname; 476 if (strncmp(p, prefix, sizeof (prefix) - 1) != 0) 477 goto nopath; 478 p += sizeof (prefix) - 1; 479 480 /* 481 * check for the default name or the platform name. 482 * also see if we used the 'compatible' name 483 * (platname == default) 484 */ 485 (void) bop_getprop("impl-arch-name", platname); 486 compat = strcmp(platname, defname) == 0; 487 len = strlen(platname); 488 if (strncmp(p, platname, len) == 0) 489 p += len; 490 else if (strncmp(p, defname, sizeof (defname) - 1) == 0) 491 p += sizeof (defname) - 1; 492 else 493 goto nopath; 494 495 /* 496 * check for /kernel/sparcv9 or just /kernel 497 */ 498 if (strncmp(p, suffix, sizeof (suffix) - 1) != 0) 499 goto nopath; 500 p += sizeof (suffix) - 1; 501 if (strncmp(p, isastr, sizeof (isastr) - 1) == 0) 502 p += sizeof (isastr) - 1; 503 504 /* 505 * check we're at the last component 506 */ 507 if (p != strrchr(fname, '/')) 508 goto nopath; 509 510 /* 511 * everything is kosher; setup modpath 512 */ 513 (void) strcpy(path, "/platform/"); 514 (void) strcat(path, platname); 515 (void) strcat(path, "/kernel"); 516 if (!compat) { 517 (void) strcat(path, " /platform/"); 518 (void) strcat(path, defname); 519 (void) strcat(path, "/kernel"); 520 } 521 return; 522 523 nopath: 524 /* 525 * Construct the directory path from the filename. 526 */ 527 if ((p = strrchr(fname, '/')) == NULL) 528 return; 529 530 while (p > fname && *(p - 1) == '/') 531 p--; /* remove trailing '/' characters */ 532 if (p == fname) 533 p++; /* so "/" -is- the modpath in this case */ 534 535 /* 536 * Remove optional isa-dependent directory name - the module 537 * subsystem will put this back again (!) 538 */ 539 len = p - fname; 540 if (len > sizeof (isastr) - 1 && 541 strncmp(&fname[len - (sizeof (isastr) - 1)], isastr, 542 sizeof (isastr) - 1) == 0) 543 p -= sizeof (isastr) - 1; 544 (void) strncpy(path, fname, p - fname); 545 } 546