1 /* $NetBSD: booke_machdep.c,v 1.35 2024/03/05 14:15:34 thorpej Exp $ */ 2 /*- 3 * Copyright (c) 2010, 2011 The NetBSD Foundation, Inc. 4 * All rights reserved. 5 * 6 * This code is derived from software contributed to The NetBSD Foundation 7 * by Raytheon BBN Technologies Corp and Defense Advanced Research Projects 8 * Agency and which was developed by Matt Thomas of 3am Software Foundry. 9 * 10 * This material is based upon work supported by the Defense Advanced Research 11 * Projects Agency and Space and Naval Warfare Systems Center, Pacific, under 12 * Contract No. N66001-09-C-2073. 13 * Approved for Public Release, Distribution Unlimited 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 * 24 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 25 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 26 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 27 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 28 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 34 * POSSIBILITY OF SUCH DAMAGE. 35 */ 36 37 #define __INTR_PRIVATE 38 #define _POWERPC_BUS_DMA_PRIVATE 39 40 #include <sys/cdefs.h> 41 __KERNEL_RCSID(0, "$NetBSD: booke_machdep.c,v 1.35 2024/03/05 14:15:34 thorpej Exp $"); 42 43 #include "ksyms.h" 44 45 #ifdef _KERNEL_OPT 46 #include "opt_ddb.h" 47 #include "opt_modular.h" 48 #include "opt_multiprocessor.h" 49 #endif 50 51 #include <sys/param.h> 52 #include <sys/cpu.h> 53 #include <sys/device.h> 54 #include <sys/intr.h> 55 #include <sys/mount.h> 56 #include <sys/msgbuf.h> 57 #include <sys/kernel.h> 58 #include <sys/reboot.h> 59 #include <sys/bus.h> 60 #include <sys/cpu.h> 61 62 #include <uvm/uvm_extern.h> 63 64 #include <dev/cons.h> 65 66 #include <powerpc/pcb.h> 67 #include <powerpc/spr.h> 68 #include <powerpc/booke/spr.h> 69 #include <powerpc/booke/cpuvar.h> 70 71 /* 72 * Global variables used here and there 73 */ 74 paddr_t msgbuf_paddr; 75 psize_t pmemsize; 76 struct vm_map *phys_map; 77 78 #ifdef MODULAR 79 register_t cpu_psluserset = PSL_USERSET; 80 register_t cpu_pslusermod = PSL_USERMOD; 81 register_t cpu_pslusermask = PSL_USERMASK; 82 #endif 83 84 static bus_addr_t booke_dma_phys_to_bus_mem(bus_dma_tag_t, bus_addr_t); 85 static bus_addr_t booke_dma_bus_mem_to_phys(bus_dma_tag_t, bus_addr_t); 86 87 88 struct powerpc_bus_dma_tag booke_bus_dma_tag = { 89 ._dmamap_create = _bus_dmamap_create, 90 ._dmamap_destroy = _bus_dmamap_destroy, 91 ._dmamap_load = _bus_dmamap_load, 92 ._dmamap_load_mbuf = _bus_dmamap_load_mbuf, 93 ._dmamap_load_uio = _bus_dmamap_load_uio, 94 ._dmamap_load_raw = _bus_dmamap_load_raw, 95 ._dmamap_unload = _bus_dmamap_unload, 96 /* 97 * The caches on BookE are coherent so we don't need to do any special 98 * cache synchronization. 99 */ 100 //._dmamap_sync = _bus_dmamap_sync, 101 ._dmamem_alloc = _bus_dmamem_alloc, 102 ._dmamem_free = _bus_dmamem_free, 103 ._dmamem_map = _bus_dmamem_map, 104 ._dmamem_unmap = _bus_dmamem_unmap, 105 ._dmamem_mmap = _bus_dmamem_mmap, 106 ._dma_phys_to_bus_mem = booke_dma_phys_to_bus_mem, 107 ._dma_bus_mem_to_phys = booke_dma_bus_mem_to_phys, 108 }; 109 110 static bus_addr_t 111 booke_dma_phys_to_bus_mem(bus_dma_tag_t t, bus_addr_t a) 112 { 113 return a; 114 } 115 116 static bus_addr_t 117 booke_dma_bus_mem_to_phys(bus_dma_tag_t t, bus_addr_t a) 118 { 119 return a; 120 } 121 122 struct cpu_md_ops cpu_md_ops; 123 124 struct cpu_softc cpu_softc[] = { 125 [0] = { 126 .cpu_ci = &cpu_info[0], 127 }, 128 #ifdef MULTIPROCESSOR 129 [CPU_MAXNUM-1] = { 130 .cpu_ci = &cpu_info[CPU_MAXNUM-1], 131 }, 132 #endif 133 }; 134 struct cpu_info cpu_info[] = { 135 [0] = { 136 .ci_curlwp = &lwp0, 137 .ci_tlb_info = &pmap_tlb0_info, 138 .ci_softc = &cpu_softc[0], 139 .ci_cpl = IPL_HIGH, 140 .ci_idepth = -1, 141 .ci_pmap_kern_segtab = &pmap_kern_segtab, 142 }, 143 #ifdef MULTIPROCESSOR 144 [CPU_MAXNUM-1] = { 145 .ci_curlwp = NULL, 146 .ci_tlb_info = &pmap_tlb0_info, 147 .ci_softc = &cpu_softc[CPU_MAXNUM-1], 148 .ci_cpl = IPL_HIGH, 149 .ci_idepth = -1, 150 .ci_pmap_kern_segtab = &pmap_kern_segtab, 151 }, 152 #endif 153 }; 154 __CTASSERT(__arraycount(cpu_info) == __arraycount(cpu_softc)); 155 156 /* 157 * This should probably be in autoconf! XXX 158 */ 159 char machine[] = MACHINE; /* from <machine/param.h> */ 160 char machine_arch[] = MACHINE_ARCH; /* from <machine/param.h> */ 161 162 char bootpath[256]; 163 164 #if NKSYMS || defined(DDB) || defined(MODULAR) 165 void *startsym, *endsym; 166 #endif 167 168 #if defined(MULTIPROCESSOR) 169 volatile struct cpu_hatch_data cpu_hatch_data __cacheline_aligned; 170 #endif 171 172 int fake_mapiodev = 1; 173 174 void 175 booke_cpu_startup(const char *model) 176 { 177 vaddr_t minaddr, maxaddr; 178 char pbuf[9]; 179 180 cpu_setmodel("%s", model); 181 182 printf("%s%s", copyright, version); 183 184 format_bytes(pbuf, sizeof(pbuf), ctob((uint64_t)physmem)); 185 printf("total memory = %s\n", pbuf); 186 187 minaddr = 0; 188 /* 189 * Allocate a submap for physio 190 */ 191 phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr, 192 VM_PHYS_SIZE, 0, false, NULL); 193 194 /* 195 * No need to allocate an mbuf cluster submap. Mbuf clusters 196 * are allocated via the pool allocator, and we use direct-mapped 197 * pool pages. 198 */ 199 200 format_bytes(pbuf, sizeof(pbuf), ptoa(uvm_availmem(false))); 201 printf("avail memory = %s\n", pbuf); 202 203 /* 204 * Register the tlb's evcnts 205 */ 206 pmap_tlb_info_evcnt_attach(curcpu()->ci_tlb_info); 207 208 /* 209 * Set up the board properties database. 210 */ 211 board_info_init(); 212 213 /* 214 * Now that we have VM, malloc()s are OK in bus_space. 215 */ 216 bus_space_mallocok(); 217 fake_mapiodev = 0; 218 219 #ifdef MULTIPROCESSOR 220 pmap_kernel()->pm_active = kcpuset_running; 221 pmap_kernel()->pm_onproc = kcpuset_running; 222 223 for (size_t i = 1; i < __arraycount(cpu_info); i++) { 224 struct cpu_info * const ci = &cpu_info[i]; 225 struct cpu_softc * const cpu = &cpu_softc[i]; 226 cpu->cpu_ci = ci; 227 cpu->cpu_bst = cpu_softc[0].cpu_bst; 228 cpu->cpu_le_bst = cpu_softc[0].cpu_le_bst; 229 cpu->cpu_bsh = cpu_softc[0].cpu_bsh; 230 cpu->cpu_highmem = cpu_softc[0].cpu_highmem; 231 ci->ci_softc = cpu; 232 ci->ci_tlb_info = &pmap_tlb0_info; 233 ci->ci_cpl = IPL_HIGH; 234 ci->ci_idepth = -1; 235 ci->ci_pmap_kern_segtab = curcpu()->ci_pmap_kern_segtab; 236 } 237 238 kcpuset_create(&cpuset_info.cpus_running, true); 239 kcpuset_create(&cpuset_info.cpus_hatched, true); 240 kcpuset_create(&cpuset_info.cpus_paused, true); 241 kcpuset_create(&cpuset_info.cpus_resumed, true); 242 kcpuset_create(&cpuset_info.cpus_halted, true); 243 244 kcpuset_set(cpuset_info.cpus_running, cpu_number()); 245 #endif /* MULTIPROCESSOR */ 246 } 247 248 static void 249 dumpsys(void) 250 { 251 252 printf("dumpsys: TBD\n"); 253 } 254 255 /* 256 * Halt or reboot the machine after syncing/dumping according to howto. 257 */ 258 void 259 cpu_reboot(int howto, char *what) 260 { 261 static int syncing; 262 static char str[256]; 263 char *ap = str, *ap1 = ap; 264 265 boothowto = howto; 266 if (!cold && !(howto & RB_NOSYNC) && !syncing) { 267 syncing = 1; 268 vfs_shutdown(); /* sync */ 269 } 270 271 splhigh(); 272 273 if (!cold && (howto & RB_DUMP)) 274 dumpsys(); 275 276 doshutdownhooks(); 277 278 pmf_system_shutdown(boothowto); 279 280 if ((howto & RB_POWERDOWN) == RB_POWERDOWN) { 281 /* Power off here if we know how...*/ 282 } 283 284 if (howto & RB_HALT) { 285 printf("The operating system has halted.\n" 286 "Press any key to reboot.\n\n"); 287 cnpollc(1); /* For proper keyboard command handling */ 288 cngetc(); 289 cnpollc(0); 290 } 291 292 printf("rebooting\n\n"); 293 if (what && *what) { 294 if (strlen(what) > sizeof str - 5) 295 printf("boot string too large, ignored\n"); 296 else { 297 strcpy(str, what); 298 ap1 = ap = str + strlen(str); 299 *ap++ = ' '; 300 } 301 } 302 *ap++ = '-'; 303 if (howto & RB_SINGLE) 304 *ap++ = 's'; 305 if (howto & RB_KDB) 306 *ap++ = 'd'; 307 *ap++ = 0; 308 if (ap[-2] == '-') 309 *ap1 = 0; 310 311 /* flush cache for msgbuf */ 312 dcache_wb(msgbuf_paddr, round_page(MSGBUFSIZE)); 313 314 __asm volatile("msync; isync"); 315 (*cpu_md_ops.md_cpu_reset)(); 316 317 printf("%s: md_cpu_reset() failed!\n", __func__); 318 #ifdef DDB 319 for (;;) 320 Debugger(); 321 #else 322 for (;;) 323 /* nothing */; 324 #endif 325 } 326 327 /* 328 * mapiodev: 329 * 330 * Allocate vm space and mapin the I/O address. Use reserved TLB 331 * mapping if one is found. 332 */ 333 void * 334 mapiodev(paddr_t pa, psize_t len, bool prefetchable) 335 { 336 const vsize_t off = pa & PAGE_MASK; 337 338 /* 339 * See if we have reserved TLB entry for the pa. This needs to be 340 * true for console as we can't use uvm during early bootstrap. 341 */ 342 void * const p = tlb_mapiodev(pa, len, prefetchable); 343 if (p != NULL) 344 return p; 345 346 if (fake_mapiodev) 347 panic("mapiodev: no TLB entry reserved for %llx+%llx", 348 (long long)pa, (long long)len); 349 350 const paddr_t orig_pa = pa; 351 const psize_t orig_len = len; 352 vsize_t align = 0; 353 pa = trunc_page(pa); 354 len = round_page(off + len); 355 /* 356 * If we are allocating a large amount (>= 1MB) try to get an 357 * aligned VA region for it so try to do a large mapping for it. 358 */ 359 if ((len & (len - 1)) == 0 && len >= 0x100000) 360 align = len; 361 362 vaddr_t va = uvm_km_alloc(kernel_map, len, align, UVM_KMF_VAONLY); 363 364 if (va == 0 && align > 0) { 365 /* 366 * Large aligned request failed. Let's just get anything. 367 */ 368 align = 0; 369 va = uvm_km_alloc(kernel_map, len, align, UVM_KMF_VAONLY); 370 } 371 if (va == 0) 372 return NULL; 373 374 if (align) { 375 /* 376 * Now try to map that via one big TLB entry. 377 */ 378 pt_entry_t pte = pte_make_kenter_pa(pa, NULL, 379 VM_PROT_READ|VM_PROT_WRITE, 380 prefetchable ? 0 : PMAP_NOCACHE); 381 if (!tlb_ioreserve(va, len, pte)) { 382 void * const p0 = tlb_mapiodev(orig_pa, orig_len, 383 prefetchable); 384 KASSERT(p0 != NULL); 385 return p0; 386 } 387 } 388 389 for (va += len, pa += len; len > 0; len -= PAGE_SIZE) { 390 va -= PAGE_SIZE; 391 pa -= PAGE_SIZE; 392 pmap_kenter_pa(va, pa, VM_PROT_READ|VM_PROT_WRITE, 393 prefetchable ? 0 : PMAP_NOCACHE); 394 } 395 pmap_update(pmap_kernel()); 396 return (void *)(va + off); 397 } 398 399 void 400 unmapiodev(vaddr_t va, vsize_t len) 401 { 402 /* Nothing to do for reserved (ie. not uvm_km_alloc'd) mappings. */ 403 if (va < VM_MIN_KERNEL_ADDRESS || va > VM_MAX_KERNEL_ADDRESS) { 404 tlb_unmapiodev(va, len); 405 return; 406 } 407 408 len = round_page((va & PAGE_MASK) + len); 409 va = trunc_page(va); 410 411 pmap_kremove(va, len); 412 uvm_km_free(kernel_map, va, len, UVM_KMF_VAONLY); 413 } 414 415 void 416 cpu_evcnt_attach(struct cpu_info *ci) 417 { 418 struct cpu_softc * const cpu = ci->ci_softc; 419 const char * const xname = ci->ci_data.cpu_name; 420 421 evcnt_attach_dynamic_nozero(&ci->ci_ev_clock, EVCNT_TYPE_INTR, 422 NULL, xname, "clock"); 423 evcnt_attach_dynamic_nozero(&cpu->cpu_ev_late_clock, EVCNT_TYPE_INTR, 424 NULL, xname, "late clock"); 425 evcnt_attach_dynamic_nozero(&cpu->cpu_ev_exec_trap_sync, EVCNT_TYPE_TRAP, 426 NULL, xname, "exec pages synced (trap)"); 427 evcnt_attach_dynamic_nozero(&ci->ci_ev_traps, EVCNT_TYPE_TRAP, 428 NULL, xname, "traps"); 429 evcnt_attach_dynamic_nozero(&ci->ci_ev_kdsi, EVCNT_TYPE_TRAP, 430 &ci->ci_ev_traps, xname, "kernel DSI traps"); 431 evcnt_attach_dynamic_nozero(&ci->ci_ev_udsi, EVCNT_TYPE_TRAP, 432 &ci->ci_ev_traps, xname, "user DSI traps"); 433 evcnt_attach_dynamic_nozero(&ci->ci_ev_udsi_fatal, EVCNT_TYPE_TRAP, 434 &ci->ci_ev_udsi, xname, "user DSI failures"); 435 evcnt_attach_dynamic_nozero(&ci->ci_ev_kisi, EVCNT_TYPE_TRAP, 436 &ci->ci_ev_traps, xname, "kernel ISI traps"); 437 evcnt_attach_dynamic_nozero(&ci->ci_ev_isi, EVCNT_TYPE_TRAP, 438 &ci->ci_ev_traps, xname, "user ISI traps"); 439 evcnt_attach_dynamic_nozero(&ci->ci_ev_isi_fatal, EVCNT_TYPE_TRAP, 440 &ci->ci_ev_isi, xname, "user ISI failures"); 441 evcnt_attach_dynamic_nozero(&ci->ci_ev_scalls, EVCNT_TYPE_TRAP, 442 &ci->ci_ev_traps, xname, "system call traps"); 443 evcnt_attach_dynamic_nozero(&ci->ci_ev_pgm, EVCNT_TYPE_TRAP, 444 &ci->ci_ev_traps, xname, "PGM traps"); 445 evcnt_attach_dynamic_nozero(&ci->ci_ev_debug, EVCNT_TYPE_TRAP, 446 &ci->ci_ev_traps, xname, "debug traps"); 447 evcnt_attach_dynamic_nozero(&ci->ci_ev_fpu, EVCNT_TYPE_TRAP, 448 &ci->ci_ev_traps, xname, "FPU unavailable traps"); 449 evcnt_attach_dynamic_nozero(&ci->ci_ev_fpusw, EVCNT_TYPE_MISC, 450 &ci->ci_ev_fpu, xname, "FPU context switches"); 451 evcnt_attach_dynamic_nozero(&ci->ci_ev_ali, EVCNT_TYPE_TRAP, 452 &ci->ci_ev_traps, xname, "user alignment traps"); 453 evcnt_attach_dynamic_nozero(&ci->ci_ev_ali_fatal, EVCNT_TYPE_TRAP, 454 &ci->ci_ev_ali, xname, "user alignment traps"); 455 evcnt_attach_dynamic_nozero(&ci->ci_ev_umchk, EVCNT_TYPE_TRAP, 456 &ci->ci_ev_umchk, xname, "user MCHK failures"); 457 evcnt_attach_dynamic_nozero(&ci->ci_ev_vec, EVCNT_TYPE_TRAP, 458 &ci->ci_ev_traps, xname, "SPE unavailable"); 459 evcnt_attach_dynamic_nozero(&ci->ci_ev_vecsw, EVCNT_TYPE_MISC, 460 &ci->ci_ev_vec, xname, "SPE context switches"); 461 evcnt_attach_dynamic_nozero(&ci->ci_ev_ipi, EVCNT_TYPE_INTR, 462 NULL, xname, "IPIs"); 463 evcnt_attach_dynamic_nozero(&ci->ci_ev_tlbmiss_soft, EVCNT_TYPE_TRAP, 464 &ci->ci_ev_traps, xname, "soft tlb misses"); 465 evcnt_attach_dynamic_nozero(&ci->ci_ev_dtlbmiss_hard, EVCNT_TYPE_TRAP, 466 &ci->ci_ev_traps, xname, "data tlb misses"); 467 evcnt_attach_dynamic_nozero(&ci->ci_ev_itlbmiss_hard, EVCNT_TYPE_TRAP, 468 &ci->ci_ev_traps, xname, "inst tlb misses"); 469 } 470 471 #ifdef MULTIPROCESSOR 472 register_t 473 cpu_hatch(void) 474 { 475 struct cpuset_info * const csi = &cpuset_info; 476 const size_t id = cpu_number(); 477 478 /* 479 * We've hatched so tell the spinup code. 480 */ 481 kcpuset_set(csi->cpus_hatched, id); 482 483 /* 484 * Loop until running bit for this cpu is set. 485 */ 486 while (!kcpuset_isset(csi->cpus_running, id)) { 487 continue; 488 } 489 490 /* 491 * Now that we are active, start the clocks. 492 */ 493 cpu_initclocks(); 494 495 /* 496 * Return sp of the idlelwp. Which we should be already using but ... 497 */ 498 return curcpu()->ci_curpcb->pcb_sp; 499 } 500 501 void 502 cpu_boot_secondary_processors(void) 503 { 504 volatile struct cpuset_info * const csi = &cpuset_info; 505 CPU_INFO_ITERATOR cii; 506 struct cpu_info *ci; 507 kcpuset_t *running; 508 509 kcpuset_create(&running, true); 510 511 for (CPU_INFO_FOREACH(cii, ci)) { 512 /* 513 * Skip this CPU if it didn't successfully hatch. 514 */ 515 if (!kcpuset_isset(csi->cpus_hatched, cpu_index(ci))) 516 continue; 517 518 KASSERT(!CPU_IS_PRIMARY(ci)); 519 KASSERT(ci->ci_data.cpu_idlelwp); 520 521 kcpuset_set(running, cpu_index(ci)); 522 } 523 KASSERT(kcpuset_match(csi->cpus_hatched, running)); 524 if (!kcpuset_iszero(running)) { 525 kcpuset_merge(csi->cpus_running, running); 526 } 527 kcpuset_destroy(running); 528 } 529 #endif 530 531 uint32_t 532 cpu_read_4(bus_addr_t a) 533 { 534 struct cpu_softc * const cpu = curcpu()->ci_softc; 535 // printf(" %s(%p, %x, %x)", __func__, cpu->cpu_bst, cpu->cpu_bsh, a); 536 return bus_space_read_4(cpu->cpu_bst, cpu->cpu_bsh, a); 537 } 538 539 uint8_t 540 cpu_read_1(bus_addr_t a) 541 { 542 struct cpu_softc * const cpu = curcpu()->ci_softc; 543 // printf(" %s(%p, %x, %x)", __func__, cpu->cpu_bst, cpu->cpu_bsh, a); 544 return bus_space_read_1(cpu->cpu_bst, cpu->cpu_bsh, a); 545 } 546 547 void 548 cpu_write_4(bus_addr_t a, uint32_t v) 549 { 550 struct cpu_softc * const cpu = curcpu()->ci_softc; 551 bus_space_write_4(cpu->cpu_bst, cpu->cpu_bsh, a, v); 552 } 553 554 void 555 cpu_write_1(bus_addr_t a, uint8_t v) 556 { 557 struct cpu_softc * const cpu = curcpu()->ci_softc; 558 bus_space_write_1(cpu->cpu_bst, cpu->cpu_bsh, a, v); 559 } 560 561 void 562 booke_sstep(struct trapframe *tf) 563 { 564 uint32_t insn; 565 566 KASSERT(tf->tf_srr1 & PSL_DE); 567 if (ufetch_32((const void *)tf->tf_srr0, &insn) != 0) 568 return; 569 570 register_t dbcr0 = DBCR0_IAC1 | DBCR0_IDM; 571 register_t dbcr1 = DBCR1_IAC1US_USER | DBCR1_IAC1ER_DS1; 572 if ((insn >> 28) == 4) { 573 uint32_t iac2 = 0; 574 if ((insn >> 26) == 0x12) { 575 const int32_t off = (((int32_t)insn << 6) >> 6) & ~3; 576 iac2 = ((insn & 2) ? 0 : tf->tf_srr0) + off; 577 dbcr0 |= DBCR0_IAC2; 578 } else if ((insn >> 26) == 0x10) { 579 const int16_t off = insn & ~3; 580 iac2 = ((insn & 2) ? 0 : tf->tf_srr0) + off; 581 dbcr0 |= DBCR0_IAC2; 582 } else if ((insn & 0xfc00fffe) == 0x4c000420) { 583 iac2 = tf->tf_ctr; 584 dbcr0 |= DBCR0_IAC2; 585 } else if ((insn & 0xfc00fffe) == 0x4c000020) { 586 iac2 = tf->tf_lr; 587 dbcr0 |= DBCR0_IAC2; 588 } 589 if (dbcr0 & DBCR0_IAC2) { 590 dbcr1 |= DBCR1_IAC2US_USER | DBCR1_IAC2ER_DS1; 591 mtspr(SPR_IAC2, iac2); 592 } 593 } 594 mtspr(SPR_IAC1, tf->tf_srr0 + 4); 595 mtspr(SPR_DBCR1, dbcr1); 596 mtspr(SPR_DBCR0, dbcr0); 597 } 598 599 #ifdef DIAGNOSTIC 600 static inline void 601 swap_data(uint64_t *data, size_t a, size_t b) 602 { 603 uint64_t swap = data[a]; 604 data[a] = data[b]; 605 data[b] = swap; 606 } 607 608 static void 609 sort_data(uint64_t *data, size_t count) 610 { 611 #if 0 612 /* 613 * Mostly classic bubble sort 614 */ 615 do { 616 size_t new_count = 0; 617 for (size_t i = 1; i < count; i++) { 618 if (tbs[i - 1] > tbs[i]) { 619 swap_tbs(tbs, i - 1, i); 620 new_count = i; 621 } 622 } 623 count = new_count; 624 } while (count > 0); 625 #else 626 /* 627 * Comb sort 628 */ 629 size_t gap = count; 630 bool swapped = false; 631 while (gap > 1 || swapped) { 632 if (gap > 1) { 633 /* 634 * phi = (1 + sqrt(5)) / 2 [golden ratio] 635 * N = 1 / (1 - e^-phi)) = 1.247330950103979 636 * 637 * We want to but can't use floating point to calculate 638 * gap = (size_t)((double)gap / N) 639 * 640 * So we will use the multiplicative inverse of N 641 * (module 65536) to achieve the division. 642 * 643 * iN = 2^16 / 1.24733... = 52540 644 * x / N == (x * iN) / 65536 645 */ 646 gap = (gap * 52540) / 65536; 647 } 648 649 swapped = false; 650 651 for (size_t i = 0; gap + i < count; i++) { 652 if (data[i] > data[i + gap]) { 653 swap_data(data, i, i + gap); 654 swapped = true; 655 } 656 } 657 } 658 #endif 659 } 660 #endif 661 662 void 663 dump_splhist(struct cpu_info *ci, void (*pr)(const char *, ...)) 664 { 665 #ifdef DIAGNOSTIC 666 struct cpu_softc * const cpu = ci->ci_softc; 667 uint64_t tbs[NIPL*NIPL]; 668 size_t ntbs = 0; 669 for (size_t to = 0; to < NIPL; to++) { 670 for (size_t from = 0; from < NIPL; from++) { 671 uint64_t tb = cpu->cpu_spl_tb[to][from]; 672 if (tb == 0) 673 continue; 674 tbs[ntbs++] = (tb << 8) | (to << 4) | from; 675 } 676 } 677 sort_data(tbs, ntbs); 678 679 if (pr == NULL) 680 pr = printf; 681 uint64_t last_tb = 0; 682 for (size_t i = 0; i < ntbs; i++) { 683 uint64_t tb = tbs[i]; 684 size_t from = tb & 15; 685 size_t to = (tb >> 4) & 15; 686 tb >>= 8; 687 (*pr)("%s(%zu) from %zu at %"PRId64"", 688 from < to ? "splraise" : "splx", 689 to, from, tb); 690 if (last_tb && from != IPL_NONE) 691 (*pr)(" (+%"PRId64")", tb - last_tb); 692 (*pr)("\n"); 693 last_tb = tb; 694 } 695 #endif 696 } 697
Indexes created Sun Sep 21 18:09:52 GMT 2025