1 /* $NetBSD: ofw.c,v 1.69 2023/12/10 23:19:12 andvar Exp $ */ 2 3 /* 4 * Copyright 1997 5 * Digital Equipment Corporation. All rights reserved. 6 * 7 * This software is furnished under license and may be used and 8 * copied only in accordance with the following terms and conditions. 9 * Subject to these conditions, you may download, copy, install, 10 * use, modify and distribute this software in source and/or binary 11 * form. No title or ownership is transferred hereby. 12 * 13 * 1) Any source code used, modified or distributed must reproduce 14 * and retain this copyright notice and list of conditions as 15 * they appear in the source file. 16 * 17 * 2) No right is granted to use any trade name, trademark, or logo of 18 * Digital Equipment Corporation. Neither the "Digital Equipment 19 * Corporation" name nor any trademark or logo of Digital Equipment 20 * Corporation may be used to endorse or promote products derived 21 * from this software without the prior written permission of 22 * Digital Equipment Corporation. 23 * 24 * 3) This software is provided "AS-IS" and any express or implied 25 * warranties, including but not limited to, any implied warranties 26 * of merchantability, fitness for a particular purpose, or 27 * non-infringement are disclaimed. In no event shall DIGITAL be 28 * liable for any damages whatsoever, and in particular, DIGITAL 29 * shall not be liable for special, indirect, consequential, or 30 * incidental damages or damages for lost profits, loss of 31 * revenue or loss of use, whether such damages arise in contract, 32 * negligence, tort, under statute, in equity, at law or otherwise, 33 * even if advised of the possibility of such damage. 34 */ 35 36 /* 37 * Routines for interfacing between NetBSD and OFW. 38 * 39 * Parts of this could be moved to an MI file in time. -JJK 40 * 41 */ 42 43 #include <sys/cdefs.h> 44 __KERNEL_RCSID(0, "$NetBSD: ofw.c,v 1.69 2023/12/10 23:19:12 andvar Exp $"); 45 46 #include <sys/param.h> 47 #include <sys/systm.h> 48 #include <sys/device.h> 49 #include <sys/kernel.h> 50 #include <sys/reboot.h> 51 #include <sys/mbuf.h> 52 #include <sys/cpu.h> 53 #include <sys/intr.h> 54 55 #include <uvm/uvm.h> 56 57 #include <dev/cons.h> 58 59 #define _ARM32_BUS_DMA_PRIVATE 60 #include <sys/bus.h> 61 62 #include <arm/locore.h> 63 64 #include <machine/bootconfig.h> 65 #include <machine/irqhandler.h> 66 67 #include <dev/ofw/openfirm.h> 68 #include <machine/ofw.h> 69 70 #include <netinet/in.h> 71 72 #if BOOT_FW_DHCP 73 #include <nfs/bootdata.h> 74 #endif 75 76 #ifdef SHARK 77 #include "machine/pio.h" 78 #include "machine/isa_machdep.h" 79 #endif 80 81 #include "isadma.h" 82 #include "igsfb_ofbus.h" 83 #include "chipsfb_ofbus.h" 84 #include "vga_ofbus.h" 85 86 #define IO_VIRT_BASE (OFW_VIRT_BASE + OFW_VIRT_SIZE) 87 #define IO_VIRT_SIZE 0x01000000 88 89 #define KERNEL_IMG_PTS 2 90 #define KERNEL_VMDATA_PTS (KERNEL_VM_SIZE >> (L1_S_SHIFT + 2)) 91 #define KERNEL_OFW_PTS 4 92 #define KERNEL_IO_PTS 4 93 94 #define KERNEL_VM_BASE (KERNEL_BASE + 0x01000000) 95 /* 96 * The range 0xf1000000 - 0xf6ffffff is available for kernel VM space 97 * OFW sits at 0xf7000000 98 */ 99 #define KERNEL_VM_SIZE 0x06000000 100 101 /* 102 * Imported variables 103 */ 104 extern BootConfig bootconfig; /* temporary, I hope */ 105 106 #ifdef DIAGNOSTIC 107 /* NOTE: These variables will be removed, well some of them */ 108 extern u_int current_mask; 109 #endif 110 111 extern int ofw_handleticks; 112 113 114 /* 115 * Imported routines 116 */ 117 extern void dump_spl_masks(void); 118 extern void dumpsys(void); 119 extern void dotickgrovelling(vaddr_t); 120 121 #define WriteWord(a, b) \ 122 *((volatile unsigned int *)(a)) = (b) 123 124 #define ReadWord(a) \ 125 (*((volatile unsigned int *)(a))) 126 127 128 /* 129 * Exported variables 130 */ 131 /* These should all be in a meminfo structure. */ 132 paddr_t physical_start; 133 paddr_t physical_freestart; 134 paddr_t physical_freeend; 135 paddr_t physical_end; 136 u_int free_pages; 137 138 paddr_t msgbufphys; 139 140 /* for storage allocation, used to be local to ofw_construct_proc0_addrspace */ 141 static vaddr_t virt_freeptr; 142 143 int ofw_callbacks = 0; /* debugging counter */ 144 145 #if (NIGSFB_OFBUS > 0) || (NCHIPSFB_OFBUS > 0) || (NVGA_OFBUS > 0) 146 int console_ihandle = 0; 147 static void reset_screen(void); 148 #endif 149 150 /**************************************************************/ 151 152 153 /* 154 * Declarations and definitions private to this module 155 * 156 */ 157 158 struct mem_region { 159 paddr_t start; 160 psize_t size; 161 }; 162 163 struct mem_translation { 164 vaddr_t virt; 165 vsize_t size; 166 paddr_t phys; 167 unsigned int mode; 168 }; 169 170 struct isa_range { 171 paddr_t isa_phys_hi; 172 paddr_t isa_phys_lo; 173 paddr_t parent_phys_start; 174 psize_t isa_size; 175 }; 176 177 struct vl_range { 178 paddr_t vl_phys_hi; 179 paddr_t vl_phys_lo; 180 paddr_t parent_phys_start; 181 psize_t vl_size; 182 }; 183 184 struct vl_isa_range { 185 paddr_t isa_phys_hi; 186 paddr_t isa_phys_lo; 187 paddr_t parent_phys_hi; 188 paddr_t parent_phys_lo; 189 psize_t isa_size; 190 }; 191 192 struct dma_range { 193 paddr_t start; 194 psize_t size; 195 }; 196 197 struct ofw_cbargs { 198 char *name; 199 int nargs; 200 int nreturns; 201 int args_n_results[12]; 202 }; 203 204 205 /* Memory info */ 206 static int nOFphysmem; 207 static struct mem_region *OFphysmem; 208 static int nOFphysavail; 209 static struct mem_region *OFphysavail; 210 static int nOFtranslations; 211 static struct mem_translation *OFtranslations; 212 static int nOFdmaranges; 213 static struct dma_range *OFdmaranges; 214 215 /* The OFW client services handle. */ 216 /* Initialized by ofw_init(). */ 217 static ofw_handle_t ofw_client_services_handle; 218 219 220 static void ofw_callbackhandler(void *); 221 static void ofw_construct_proc0_addrspace(void); 222 static void ofw_getphysmeminfo(void); 223 static void ofw_getvirttranslations(void); 224 static void *ofw_malloc(vsize_t size); 225 static void ofw_claimpages(vaddr_t *, pv_addr_t *, vsize_t); 226 static void ofw_discardmappings(vaddr_t, vaddr_t, vsize_t); 227 static int ofw_mem_ihandle(void); 228 static int ofw_mmu_ihandle(void); 229 static paddr_t ofw_claimphys(paddr_t, psize_t, paddr_t); 230 #if 0 231 static paddr_t ofw_releasephys(paddr_t, psize_t); 232 #endif 233 static vaddr_t ofw_claimvirt(vaddr_t, vsize_t, vaddr_t); 234 static void ofw_settranslation(vaddr_t, paddr_t, vsize_t, int); 235 static void ofw_initallocator(void); 236 static void ofw_configisaonly(paddr_t *, paddr_t *); 237 static void ofw_configvl(int, paddr_t *, paddr_t *); 238 static vaddr_t ofw_valloc(vsize_t, vaddr_t); 239 240 241 /* 242 * DHCP hooks. For a first cut, we look to see if there is a DHCP 243 * packet that was saved by the firmware. If not, we proceed as before, 244 * getting hand-configured data from NVRAM. If there is one, we get the 245 * packet, and extract the data from it. For now, we hand that data up 246 * in the boot_args string as before. 247 */ 248 249 250 /**************************************************************/ 251 252 253 /* 254 * 255 * Support routines for xxx_machdep.c 256 * 257 * The intent is that all OFW-based configurations use the 258 * exported routines in this file to do their business. If 259 * they need to override some function they are free to do so. 260 * 261 * The exported routines are: 262 * 263 * openfirmware 264 * ofw_init 265 * ofw_boot 266 * ofw_getbootinfo 267 * ofw_configmem 268 * ofw_configisa 269 * ofw_configisadma 270 * ofw_gettranslation 271 * ofw_map 272 * ofw_getcleaninfo 273 */ 274 275 276 int 277 openfirmware(void *args) 278 { 279 int ofw_result; 280 u_int saved_irq_state; 281 282 /* OFW is not re-entrant, so we wrap a mutex around the call. */ 283 saved_irq_state = disable_interrupts(I32_bit); 284 ofw_result = ofw_client_services_handle(args); 285 (void)restore_interrupts(saved_irq_state); 286 287 return(ofw_result); 288 } 289 290 291 void 292 ofw_init(ofw_handle_t ofw_handle) 293 { 294 ofw_client_services_handle = ofw_handle; 295 296 /* Everything we allocate in the remainder of this block is 297 * constrained to be in the "kernel-static" portion of the 298 * virtual address space (i.e., 0xF0000000 - 0xF1000000). 299 * This is because all such objects are expected to be in 300 * that range by NetBSD, or the objects will be re-mapped 301 * after the page-table-switch to other specific locations. 302 * In the latter case, it's simplest if our pre-switch handles 303 * on those objects are in regions that are already "well- 304 * known." (Otherwise, the cloning of the OFW-managed address- 305 * space becomes more awkward.) To minimize the number of L2 306 * page tables that we use, we are further restricting the 307 * remaining allocations in this block to the bottom quarter of 308 * the legal range. OFW will have loaded the kernel text+data+bss 309 * starting at the bottom of the range, and we will allocate 310 * objects from the top, moving downwards. The two sub-regions 311 * will collide if their total sizes hit 8MB. The current total 312 * is <1.5MB, but INSTALL kernels are > 4MB, so hence the 8MB 313 * limit. The variable virt-freeptr represents the next free va 314 * (moving downwards). 315 */ 316 virt_freeptr = KERNEL_BASE + (0x00400000 * KERNEL_IMG_PTS); 317 } 318 319 320 void 321 ofw_boot(int howto, char *bootstr) 322 { 323 324 #ifdef DIAGNOSTIC 325 printf("boot: howto=%08x curlwp=%p\n", howto, curlwp); 326 printf("current_mask=%08x\n", current_mask); 327 328 printf("ipl_bio=%08x ipl_net=%08x ipl_tty=%08x ipl_vm=%08x\n", 329 irqmasks[IPL_BIO], irqmasks[IPL_NET], irqmasks[IPL_TTY], 330 irqmasks[IPL_VM]); 331 printf("ipl_clock=%08x ipl_none=%08x\n", 332 irqmasks[IPL_CLOCK], irqmasks[IPL_NONE]); 333 334 dump_spl_masks(); 335 #endif 336 337 /* 338 * If we are still cold then hit the air brakes 339 * and crash to earth fast 340 */ 341 if (cold) { 342 doshutdownhooks(); 343 pmf_system_shutdown(boothowto); 344 printf("Halted while still in the ICE age.\n"); 345 printf("The operating system has halted.\n"); 346 goto ofw_exit; 347 /*NOTREACHED*/ 348 } 349 350 /* 351 * If RB_NOSYNC was not specified sync the discs. 352 * Note: Unless cold is set to 1 here, syslogd will die during the unmount. 353 * It looks like syslogd is getting woken up only to find that it cannot 354 * page part of the binary in as the filesystem has been unmounted. 355 */ 356 if (!(howto & RB_NOSYNC)) 357 bootsync(); 358 359 /* Say NO to interrupts */ 360 splhigh(); 361 362 /* Do a dump if requested. */ 363 if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP) 364 dumpsys(); 365 366 /* Run any shutdown hooks */ 367 doshutdownhooks(); 368 369 pmf_system_shutdown(boothowto); 370 371 /* Make sure IRQ's are disabled */ 372 IRQdisable; 373 374 if (howto & RB_HALT) { 375 printf("The operating system has halted.\n"); 376 goto ofw_exit; 377 } 378 379 /* Tell the user we are booting */ 380 printf("rebooting...\n"); 381 382 /* Jump into the OFW boot routine. */ 383 { 384 static char str[256]; 385 char *ap = str, *ap1 = ap; 386 387 if (bootstr && *bootstr) { 388 if (strlen(bootstr) > sizeof str - 5) 389 printf("boot string too large, ignored\n"); 390 else { 391 strcpy(str, bootstr); 392 ap1 = ap = str + strlen(str); 393 *ap++ = ' '; 394 } 395 } 396 *ap++ = '-'; 397 if (howto & RB_SINGLE) 398 *ap++ = 's'; 399 if (howto & RB_KDB) 400 *ap++ = 'd'; 401 *ap++ = 0; 402 if (ap[-2] == '-') 403 *ap1 = 0; 404 #if (NIGSFB_OFBUS > 0) || (NCHIPSFB_OFBUS > 0) || (NVGA_OFBUS > 0) 405 reset_screen(); 406 #endif 407 OF_boot(str); 408 /*NOTREACHED*/ 409 } 410 411 ofw_exit: 412 printf("Calling OF_exit...\n"); 413 #if (NIGSFB_OFBUS > 0) || (NCHIPSFB_OFBUS > 0) || (NVGA_OFBUS > 0) 414 reset_screen(); 415 #endif 416 OF_exit(); 417 /*NOTREACHED*/ 418 } 419 420 421 #if BOOT_FW_DHCP 422 423 extern char *ip2dotted(struct in_addr); 424 425 /* 426 * Get DHCP data from OFW 427 */ 428 429 void 430 get_fw_dhcp_data(struct bootdata *bdp) 431 { 432 int chosen; 433 int dhcplen; 434 435 memset((char *)bdp, 0, sizeof(*bdp)); 436 if ((chosen = OF_finddevice("/chosen")) == -1) 437 panic("no /chosen from OFW"); 438 if ((dhcplen = OF_getproplen(chosen, "bootp-response")) > 0) { 439 u_char *cp; 440 int dhcp_type = 0; 441 char *ip; 442 443 /* 444 * OFW saved a DHCP (or BOOTP) packet for us. 445 */ 446 if (dhcplen > sizeof(bdp->dhcp_packet)) 447 panic("DHCP packet too large"); 448 OF_getprop(chosen, "bootp-response", &bdp->dhcp_packet, 449 sizeof(bdp->dhcp_packet)); 450 SANITY(bdp->dhcp_packet.op == BOOTREPLY, "bogus DHCP packet"); 451 /* 452 * Collect the interesting data from DHCP into 453 * the bootdata structure. 454 */ 455 bdp->ip_address = bdp->dhcp_packet.yiaddr; 456 ip = ip2dotted(bdp->ip_address); 457 if (memcmp(bdp->dhcp_packet.options, DHCP_OPTIONS_COOKIE, 4) == 0) 458 parse_dhcp_options(&bdp->dhcp_packet, 459 bdp->dhcp_packet.options + 4, 460 &bdp->dhcp_packet.options[dhcplen 461 - DHCP_FIXED_NON_UDP], bdp, ip); 462 if (bdp->root_ip.s_addr == 0) 463 bdp->root_ip = bdp->dhcp_packet.siaddr; 464 if (bdp->swap_ip.s_addr == 0) 465 bdp->swap_ip = bdp->dhcp_packet.siaddr; 466 } 467 /* 468 * If the DHCP packet did not contain all the necessary data, 469 * look in NVRAM for the missing parts. 470 */ 471 { 472 int options; 473 int proplen; 474 #define BOOTJUNKV_SIZE 256 475 char bootjunkv[BOOTJUNKV_SIZE]; /* minimize stack usage */ 476 477 478 if ((options = OF_finddevice("/options")) == -1) 479 panic("can't find /options"); 480 if (bdp->ip_address.s_addr == 0 && 481 (proplen = OF_getprop(options, "ipaddr", 482 bootjunkv, BOOTJUNKV_SIZE - 1)) > 0) { 483 bootjunkv[proplen] = '\0'; 484 if (dotted2ip(bootjunkv, &bdp->ip_address.s_addr) == 0) 485 bdp->ip_address.s_addr = 0; 486 } 487 if (bdp->ip_mask.s_addr == 0 && 488 (proplen = OF_getprop(options, "netmask", 489 bootjunkv, BOOTJUNKV_SIZE - 1)) > 0) { 490 bootjunkv[proplen] = '\0'; 491 if (dotted2ip(bootjunkv, &bdp->ip_mask.s_addr) == 0) 492 bdp->ip_mask.s_addr = 0; 493 } 494 if (bdp->hostname[0] == '\0' && 495 (proplen = OF_getprop(options, "hostname", 496 bdp->hostname, sizeof(bdp->hostname) - 1)) > 0) { 497 bdp->hostname[proplen] = '\0'; 498 } 499 if (bdp->root[0] == '\0' && 500 (proplen = OF_getprop(options, "rootfs", 501 bootjunkv, BOOTJUNKV_SIZE - 1)) > 0) { 502 bootjunkv[proplen] = '\0'; 503 parse_server_path(bootjunkv, &bdp->root_ip, bdp->root); 504 } 505 if (bdp->swap[0] == '\0' && 506 (proplen = OF_getprop(options, "swapfs", 507 bootjunkv, BOOTJUNKV_SIZE - 1)) > 0) { 508 bootjunkv[proplen] = '\0'; 509 parse_server_path(bootjunkv, &bdp->swap_ip, bdp->swap); 510 } 511 } 512 } 513 514 #endif /* BOOT_FW_DHCP */ 515 516 void 517 ofw_getbootinfo(char **bp_pp, char **ba_pp) 518 { 519 int chosen; 520 int bp_len; 521 int ba_len; 522 char *bootpathv; 523 char *bootargsv; 524 525 /* Read the bootpath and bootargs out of OFW. */ 526 /* XXX is bootpath still interesting? --emg */ 527 if ((chosen = OF_finddevice("/chosen")) == -1) 528 panic("no /chosen from OFW"); 529 bp_len = OF_getproplen(chosen, "bootpath"); 530 ba_len = OF_getproplen(chosen, "bootargs"); 531 if (bp_len < 0 || ba_len < 0) 532 panic("can't get boot data from OFW"); 533 534 bootpathv = (char *)ofw_malloc(bp_len); 535 bootargsv = (char *)ofw_malloc(ba_len); 536 537 if (bp_len) 538 OF_getprop(chosen, "bootpath", bootpathv, bp_len); 539 else 540 bootpathv[0] = '\0'; 541 542 if (ba_len) 543 OF_getprop(chosen, "bootargs", bootargsv, ba_len); 544 else 545 bootargsv[0] = '\0'; 546 547 *bp_pp = bootpathv; 548 *ba_pp = bootargsv; 549 #ifdef DIAGNOSTIC 550 printf("bootpath=<%s>, bootargs=<%s>\n", bootpathv, bootargsv); 551 #endif 552 } 553 554 paddr_t 555 ofw_getcleaninfo(void) 556 { 557 int cpu; 558 vaddr_t vclean; 559 paddr_t pclean; 560 561 if ((cpu = OF_finddevice("/cpu")) == -1) 562 panic("no /cpu from OFW"); 563 564 if ((OF_getprop(cpu, "d-cache-flush-address", &vclean, 565 sizeof(vclean))) != sizeof(vclean)) { 566 #ifdef DEBUG 567 printf("no OFW d-cache-flush-address property\n"); 568 #endif 569 return -1; 570 } 571 572 if ((pclean = ofw_gettranslation( 573 of_decode_int((unsigned char *)&vclean))) == -1) 574 panic("OFW failed to translate cache flush address"); 575 576 return pclean; 577 } 578 579 void 580 ofw_configisa(paddr_t *pio, paddr_t *pmem) 581 { 582 int vl; 583 584 if ((vl = OF_finddevice("/vlbus")) == -1) /* old style OFW dev info tree */ 585 ofw_configisaonly(pio, pmem); 586 else /* old style OFW dev info tree */ 587 ofw_configvl(vl, pio, pmem); 588 } 589 590 static void 591 ofw_configisaonly(paddr_t *pio, paddr_t *pmem) 592 { 593 int isa; 594 int rangeidx; 595 int size; 596 paddr_t hi, start; 597 struct isa_range ranges[2]; 598 599 if ((isa = OF_finddevice("/isa")) == -1) 600 panic("OFW has no /isa device node"); 601 602 /* expect to find two isa ranges: IO/data and memory/data */ 603 if ((size = OF_getprop(isa, "ranges", ranges, sizeof(ranges))) 604 != sizeof(ranges)) 605 panic("unexpected size of OFW /isa ranges property: %d", size); 606 607 *pio = *pmem = -1; 608 609 for (rangeidx = 0; rangeidx < 2; ++rangeidx) { 610 hi = of_decode_int((unsigned char *) 611 &ranges[rangeidx].isa_phys_hi); 612 start = of_decode_int((unsigned char *) 613 &ranges[rangeidx].parent_phys_start); 614 615 if (hi & 1) { /* then I/O space */ 616 *pio = start; 617 } else { 618 *pmem = start; 619 } 620 } /* END for */ 621 622 if ((*pio == -1) || (*pmem == -1)) 623 panic("bad OFW /isa ranges property"); 624 625 } 626 627 static void 628 ofw_configvl(int vl, paddr_t *pio, paddr_t *pmem) 629 { 630 int isa; 631 int ir, vr; 632 int size; 633 paddr_t hi, start; 634 struct vl_isa_range isa_ranges[2]; 635 struct vl_range vl_ranges[2]; 636 637 if ((isa = OF_finddevice("/vlbus/isa")) == -1) 638 panic("OFW has no /vlbus/isa device node"); 639 640 /* expect to find two isa ranges: IO/data and memory/data */ 641 if ((size = OF_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges))) 642 != sizeof(isa_ranges)) 643 panic("unexpected size of OFW /vlbus/isa ranges property: %d", 644 size); 645 646 /* expect to find two vl ranges: IO/data and memory/data */ 647 if ((size = OF_getprop(vl, "ranges", vl_ranges, sizeof(vl_ranges))) 648 != sizeof(vl_ranges)) 649 panic("unexpected size of OFW /vlbus ranges property: %d", size); 650 651 *pio = -1; 652 *pmem = -1; 653 654 for (ir = 0; ir < 2; ++ir) { 655 for (vr = 0; vr < 2; ++vr) { 656 if ((isa_ranges[ir].parent_phys_hi 657 == vl_ranges[vr].vl_phys_hi) && 658 (isa_ranges[ir].parent_phys_lo 659 == vl_ranges[vr].vl_phys_lo)) { 660 hi = of_decode_int((unsigned char *) 661 &isa_ranges[ir].isa_phys_hi); 662 start = of_decode_int((unsigned char *) 663 &vl_ranges[vr].parent_phys_start); 664 665 if (hi & 1) { /* then I/O space */ 666 *pio = start; 667 } else { 668 *pmem = start; 669 } 670 } /* END if */ 671 } /* END for */ 672 } /* END for */ 673 674 if ((*pio == -1) || (*pmem == -1)) 675 panic("bad OFW /isa ranges property"); 676 } 677 678 #if NISADMA > 0 679 struct arm32_dma_range *shark_isa_dma_ranges; 680 int shark_isa_dma_nranges; 681 #endif 682 683 void 684 ofw_configisadma(paddr_t *pdma) 685 { 686 int root; 687 int rangeidx; 688 int size; 689 struct dma_range *dr; 690 691 if ((root = OF_finddevice("/")) == -1 || 692 (size = OF_getproplen(root, "dma-ranges")) <= 0 || 693 (OFdmaranges = (struct dma_range *)ofw_malloc(size)) == 0 || 694 OF_getprop(root, "dma-ranges", OFdmaranges, size) != size) 695 panic("bad / dma-ranges property"); 696 697 nOFdmaranges = size / sizeof(struct dma_range); 698 699 #if NISADMA > 0 700 /* Allocate storage for non-OFW representation of the range. */ 701 shark_isa_dma_ranges = ofw_malloc(nOFdmaranges * 702 sizeof(*shark_isa_dma_ranges)); 703 if (shark_isa_dma_ranges == NULL) 704 panic("unable to allocate shark_isa_dma_ranges"); 705 shark_isa_dma_nranges = nOFdmaranges; 706 #endif 707 708 for (rangeidx = 0, dr = OFdmaranges; rangeidx < nOFdmaranges; 709 ++rangeidx, ++dr) { 710 dr->start = of_decode_int((unsigned char *)&dr->start); 711 dr->size = of_decode_int((unsigned char *)&dr->size); 712 #if NISADMA > 0 713 shark_isa_dma_ranges[rangeidx].dr_sysbase = dr->start; 714 shark_isa_dma_ranges[rangeidx].dr_busbase = dr->start; 715 shark_isa_dma_ranges[rangeidx].dr_len = dr->size; 716 #endif 717 } 718 719 #ifdef DEBUG 720 printf("DMA ranges size = %d\n", size); 721 722 for (rangeidx = 0; rangeidx < nOFdmaranges; ++rangeidx) { 723 printf("%08lx %08lx\n", 724 (u_long)OFdmaranges[rangeidx].start, 725 (u_long)OFdmaranges[rangeidx].size); 726 } 727 #endif 728 } 729 730 /* 731 * Memory configuration: 732 * 733 * We start off running in the environment provided by OFW. 734 * This has the MMU turned on, the kernel code and data 735 * mapped-in at KERNEL_BASE (0xF0000000), OFW's text and 736 * data mapped-in at OFW_VIRT_BASE (0xF7000000), and (possibly) 737 * page0 mapped-in at 0x0. 738 * 739 * The strategy is to set-up the address space for proc0 -- 740 * including the allocation of space for new page tables -- while 741 * memory is still managed by OFW. We then effectively create a 742 * copy of the address space by dumping all of OFW's translations 743 * and poking them into the new page tables. We then notify OFW 744 * that we are assuming control of memory-management by installing 745 * our callback-handler, and switch to the NetBSD-managed page 746 * tables with the cpu_setttb() call. 747 * 748 * This scheme may cause some amount of memory to be wasted within 749 * OFW as dead page tables, but it shouldn't be more than about 750 * 20-30KB. (It's also possible that OFW will re-use the space.) 751 */ 752 void 753 ofw_configmem(void) 754 { 755 int i; 756 757 /* Set-up proc0 address space. */ 758 ofw_construct_proc0_addrspace(); 759 760 /* 761 * Get a dump of OFW's picture of physical memory. 762 * This is used below to initialize a load of variables used by pmap. 763 * We get it now rather than later because we are about to 764 * tell OFW to stop managing memory. 765 */ 766 ofw_getphysmeminfo(); 767 768 /* We are about to take control of memory-management from OFW. 769 * Establish callbacks for OFW to use for its future memory needs. 770 * This is required for us to keep using OFW services. 771 */ 772 773 /* First initialize our callback memory allocator. */ 774 ofw_initallocator(); 775 776 OF_set_callback(ofw_callbackhandler); 777 778 /* Switch to the proc0 pagetables. */ 779 cpu_domains((DOMAIN_CLIENT << (PMAP_DOMAIN_KERNEL*2)) | DOMAIN_CLIENT); 780 cpu_setttb(kernel_l1pt.pv_pa, true); 781 cpu_tlb_flushID(); 782 cpu_domains(DOMAIN_CLIENT << (PMAP_DOMAIN_KERNEL*2)); 783 784 /* 785 * Moved from cpu_startup() as data_abort_handler() references 786 * this during uvm init 787 */ 788 uvm_lwp_setuarea(&lwp0, kernelstack.pv_va); 789 790 /* Set-up the various globals which describe physical memory for pmap. */ 791 { 792 struct mem_region *mp; 793 int totalcnt; 794 int availcnt; 795 796 /* physmem, physical_start, physical_end */ 797 physmem = 0; 798 for (totalcnt = 0, mp = OFphysmem; totalcnt < nOFphysmem; 799 totalcnt++, mp++) { 800 #ifdef OLDPRINTFS 801 printf("physmem: %lx, %lx\n", mp->start, mp->size); 802 #endif 803 physmem += btoc(mp->size); 804 } 805 physical_start = OFphysmem[0].start; 806 mp--; 807 physical_end = mp->start + mp->size; 808 809 /* free_pages, physical_freestart, physical_freeend */ 810 free_pages = 0; 811 for (availcnt = 0, mp = OFphysavail; availcnt < nOFphysavail; 812 availcnt++, mp++) { 813 #ifdef OLDPRINTFS 814 printf("physavail: %lx, %lx\n", mp->start, mp->size); 815 #endif 816 free_pages += btoc(mp->size); 817 } 818 physical_freestart = OFphysavail[0].start; 819 mp--; 820 physical_freeend = mp->start + mp->size; 821 #ifdef OLDPRINTFS 822 printf("pmap_bootstrap: physmem = %lx, free_pages = %x\n", 823 physmem, free_pages); 824 #endif 825 826 /* 827 * This is a hack to work with the existing pmap code. 828 * That code depends on a RiscPC BootConfig structure 829 * containing, among other things, an array describing 830 * the regions of physical memory. So, for now, we need 831 * to stuff our OFW-derived physical memory info into a 832 * "fake" BootConfig structure. 833 * 834 * An added twist is that we initialize the BootConfig 835 * structure with our "available" physical memory regions 836 * rather than the "total" physical memory regions. Why? 837 * Because: 838 * 839 * (a) the VM code requires that the "free" pages it is 840 * initialized with have consecutive indices. This 841 * allows it to use more efficient data structures 842 * (presumably). 843 * (b) the current pmap routines which report the initial 844 * set of free page indices (pmap_next_page) and 845 * which map addresses to indices (pmap_page_index) 846 * assume that the free pages are consecutive across 847 * memory region boundaries. 848 * 849 * This means that memory which is "stolen" at startup time 850 * (say, for page descriptors) MUST come from either the 851 * bottom of the first region or the top of the last. 852 * 853 * This requirement doesn't mesh well with OFW (or at least 854 * our use of it). We can get around it for the time being 855 * by pretending that our "available" region array describes 856 * all of our physical memory. This may cause some important 857 * information to be excluded from a dump file, but so far 858 * I haven't come across any other negative effects. 859 * 860 * In the long-run we should fix the index 861 * generation/translation code in the pmap module. 862 */ 863 864 if (DRAM_BLOCKS < (availcnt + 1)) 865 panic("more ofw memory regions than bootconfig blocks"); 866 867 for (i = 0, mp = OFphysavail; i < nOFphysavail; i++, mp++) { 868 bootconfig.dram[i].address = mp->start; 869 bootconfig.dram[i].pages = btoc(mp->size); 870 } 871 bootconfig.dramblocks = availcnt; 872 } 873 874 uvm_md_init(); 875 876 /* XXX Please kill this code dead. */ 877 for (i = 0; i < bootconfig.dramblocks; i++) { 878 paddr_t start = (paddr_t)bootconfig.dram[i].address; 879 paddr_t end = start + (bootconfig.dram[i].pages * PAGE_SIZE); 880 #if NISADMA > 0 881 paddr_t istart, isize; 882 #endif 883 884 if (start < physical_freestart) 885 start = physical_freestart; 886 if (end > physical_freeend) 887 end = physical_freeend; 888 889 #if 0 890 printf("%d: %lx -> %lx\n", loop, start, end - 1); 891 #endif 892 893 #if NISADMA > 0 894 if (arm32_dma_range_intersect(shark_isa_dma_ranges, 895 shark_isa_dma_nranges, 896 start, end - start, 897 &istart, &isize)) { 898 /* 899 * Place the pages that intersect with the 900 * ISA DMA range onto the ISA DMA free list. 901 */ 902 #if 0 903 printf(" ISADMA 0x%lx -> 0x%lx\n", istart, 904 istart + isize - 1); 905 #endif 906 uvm_page_physload(atop(istart), 907 atop(istart + isize), atop(istart), 908 atop(istart + isize), VM_FREELIST_ISADMA); 909 910 /* 911 * Load the pieces that come before the 912 * intersection onto the default free list. 913 */ 914 if (start < istart) { 915 #if 0 916 printf(" BEFORE 0x%lx -> 0x%lx\n", 917 start, istart - 1); 918 #endif 919 uvm_page_physload(atop(start), 920 atop(istart), atop(start), 921 atop(istart), VM_FREELIST_DEFAULT); 922 } 923 924 /* 925 * Load the pieces that come after the 926 * intersection onto the default free list. 927 */ 928 if ((istart + isize) < end) { 929 #if 0 930 printf(" AFTER 0x%lx -> 0x%lx\n", 931 (istart + isize), end - 1); 932 #endif 933 uvm_page_physload(atop(istart + isize), 934 atop(end), atop(istart + isize), 935 atop(end), VM_FREELIST_DEFAULT); 936 } 937 } else { 938 uvm_page_physload(atop(start), atop(end), 939 atop(start), atop(end), VM_FREELIST_DEFAULT); 940 } 941 #else /* NISADMA > 0 */ 942 uvm_page_physload(atop(start), atop(end), 943 atop(start), atop(end), VM_FREELIST_DEFAULT); 944 #endif /* NISADMA > 0 */ 945 } 946 947 /* Initialize pmap module. */ 948 pmap_bootstrap(KERNEL_VM_BASE, KERNEL_VM_BASE + KERNEL_VM_SIZE); 949 } 950 951 952 /* 953 ************************************************************ 954 955 Routines private to this module 956 957 ************************************************************ 958 */ 959 960 /* N.B. Not supposed to call printf in callback-handler! Could deadlock! */ 961 static void 962 ofw_callbackhandler(void *v) 963 { 964 struct ofw_cbargs *args = v; 965 char *name = args->name; 966 int nargs = args->nargs; 967 int nreturns = args->nreturns; 968 int *args_n_results = args->args_n_results; 969 970 ofw_callbacks++; 971 972 #if defined(OFWGENCFG) 973 /* Check this first, so that we don't waste IRQ time parsing. */ 974 if (strcmp(name, "tick") == 0) { 975 vaddr_t frame; 976 977 /* Check format. */ 978 if (nargs != 1 || nreturns < 1) { 979 args_n_results[nargs] = -1; 980 args->nreturns = 1; 981 return; 982 } 983 args_n_results[nargs] = 0; /* properly formatted request */ 984 985 /* 986 * Note that we are running in the IRQ frame, with interrupts 987 * disabled. 988 * 989 * We need to do two things here: 990 * - copy a few words out of the input frame into a global 991 * area, for later use by our real tick-handling code 992 * - patch a few words in the frame so that when OFW returns 993 * from the interrupt it will resume with our handler 994 * rather than the code that was actually interrupted. 995 * Our handler will resume when it finishes with the code 996 * that was actually interrupted. 997 * 998 * It's simplest to do this in assembler, since it requires 999 * switching frames and grovelling about with registers. 1000 */ 1001 frame = (vaddr_t)args_n_results[0]; 1002 if (ofw_handleticks) 1003 dotickgrovelling(frame); 1004 args_n_results[nargs + 1] = frame; 1005 args->nreturns = 1; 1006 } else 1007 #endif 1008 1009 if (strcmp(name, "map") == 0) { 1010 vaddr_t va; 1011 paddr_t pa; 1012 vsize_t size; 1013 int mode; 1014 int ap_bits; 1015 int dom_bits; 1016 int cb_bits; 1017 1018 /* Check format. */ 1019 if (nargs != 4 || nreturns < 2) { 1020 args_n_results[nargs] = -1; 1021 args->nreturns = 1; 1022 return; 1023 } 1024 args_n_results[nargs] = 0; /* properly formatted request */ 1025 1026 pa = (paddr_t)args_n_results[0]; 1027 va = (vaddr_t)args_n_results[1]; 1028 size = (vsize_t)args_n_results[2]; 1029 mode = args_n_results[3]; 1030 ap_bits = (mode & 0x00000C00); 1031 dom_bits = (mode & 0x000001E0); 1032 cb_bits = (mode & 0x000000C0); 1033 1034 /* Sanity checks. */ 1035 if ((va & PGOFSET) != 0 || va < OFW_VIRT_BASE || 1036 (va + size) > (OFW_VIRT_BASE + OFW_VIRT_SIZE) || 1037 (pa & PGOFSET) != 0 || (size & PGOFSET) != 0 || 1038 size == 0 || (dom_bits >> 5) != 0) { 1039 args_n_results[nargs + 1] = -1; 1040 args->nreturns = 1; 1041 return; 1042 } 1043 1044 /* Write-back anything stuck in the cache. */ 1045 cpu_idcache_wbinv_all(); 1046 1047 /* Install new mappings. */ 1048 { 1049 pt_entry_t *ptep = vtopte(va); 1050 KASSERT(ptep + size / L2_S_SIZE == vtopte(va + size)); 1051 pt_entry_t npte = pa | L2_TYPE_S | L2_AP(ap_bits) 1052 | cb_bits; 1053 1054 ap_bits >>= 10; 1055 for (size_t npages = size >> PGSHIFT; 1056 npages-- > 0; 1057 ptep += PAGE_SIZE / L2_S_SIZE, npte += PAGE_SIZE) { 1058 l2pte_set(ptep, npte, 0); 1059 } 1060 PTE_SYNC_RANGE(vtopte(va), size >> L2_S_SHIFT); 1061 } 1062 1063 /* Clean out tlb. */ 1064 cpu_tlb_flushID(); 1065 1066 args_n_results[nargs + 1] = 0; 1067 args->nreturns = 2; 1068 } else if (strcmp(name, "unmap") == 0) { 1069 vaddr_t va; 1070 vsize_t size; 1071 1072 /* Check format. */ 1073 if (nargs != 2 || nreturns < 1) { 1074 args_n_results[nargs] = -1; 1075 args->nreturns = 1; 1076 return; 1077 } 1078 args_n_results[nargs] = 0; /* properly formatted request */ 1079 1080 va = (vaddr_t)args_n_results[0]; 1081 size = (vsize_t)args_n_results[1]; 1082 1083 /* Sanity checks. */ 1084 if ((va & PGOFSET) != 0 || va < OFW_VIRT_BASE || 1085 (va + size) > (OFW_VIRT_BASE + OFW_VIRT_SIZE) || 1086 (size & PGOFSET) != 0 || size == 0) { 1087 args_n_results[nargs + 1] = -1; 1088 args->nreturns = 1; 1089 return; 1090 } 1091 1092 /* Write-back anything stuck in the cache. */ 1093 cpu_idcache_wbinv_all(); 1094 1095 /* Zero the mappings. */ 1096 { 1097 pt_entry_t *ptep = vtopte(va); 1098 1099 for (size_t npages = size >> PGSHIFT; 1100 npages-- > 0; 1101 ptep += PAGE_SIZE / L2_S_SIZE) { 1102 l2pte_reset(ptep); 1103 } 1104 PTE_SYNC_RANGE(vtopte(va), size >> L2_S_SHIFT); 1105 } 1106 1107 /* Clean out tlb. */ 1108 cpu_tlb_flushID(); 1109 1110 args->nreturns = 1; 1111 } else if (strcmp(name, "translate") == 0) { 1112 vaddr_t va; 1113 paddr_t pa; 1114 int mode; 1115 pt_entry_t pte; 1116 1117 /* Check format. */ 1118 if (nargs != 1 || nreturns < 4) { 1119 args_n_results[nargs] = -1; 1120 args->nreturns = 1; 1121 return; 1122 } 1123 args_n_results[nargs] = 0; /* properly formatted request */ 1124 1125 va = (vaddr_t)args_n_results[0]; 1126 1127 /* Sanity checks. 1128 * For now, I am only willing to translate va's in the 1129 * "ofw range." Eventually, I may be more generous. -JJK 1130 */ 1131 if ((va & PGOFSET) != 0 || va < OFW_VIRT_BASE || 1132 va >= (OFW_VIRT_BASE + OFW_VIRT_SIZE)) { 1133 args_n_results[nargs + 1] = -1; 1134 args->nreturns = 1; 1135 return; 1136 } 1137 1138 /* Lookup mapping. */ 1139 pte = *vtopte(va); 1140 if (pte == 0) { 1141 /* No mapping. */ 1142 args_n_results[nargs + 1] = -1; 1143 args->nreturns = 2; 1144 } else { 1145 /* Existing mapping. */ 1146 pa = (pte & L2_S_FRAME) | (va & L2_S_OFFSET); 1147 mode = (pte & 0x0C00) | (0 << 5) | (pte & 0x000C); /* AP | DOM | CB */ 1148 1149 args_n_results[nargs + 1] = 0; 1150 args_n_results[nargs + 2] = pa; 1151 args_n_results[nargs + 3] = mode; 1152 args->nreturns = 4; 1153 } 1154 } else if (strcmp(name, "claim-phys") == 0) { 1155 struct pglist alloclist; 1156 paddr_t low, high, align; 1157 psize_t size; 1158 1159 /* 1160 * XXX 1161 * XXX THIS IS A GROSS HACK AND NEEDS TO BE REWRITTEN. -- cgd 1162 * XXX 1163 */ 1164 1165 /* Check format. */ 1166 if (nargs != 4 || nreturns < 3) { 1167 args_n_results[nargs] = -1; 1168 args->nreturns = 1; 1169 return; 1170 } 1171 args_n_results[nargs] = 0; /* properly formatted request */ 1172 1173 low = args_n_results[0]; 1174 size = args_n_results[2]; 1175 align = args_n_results[3]; 1176 high = args_n_results[1] + size; 1177 1178 #if 0 1179 printf("claim-phys: low = 0x%x, size = 0x%x, align = 0x%x, high = 0x%x\n", 1180 low, size, align, high); 1181 align = size; 1182 printf("forcing align to be 0x%x\n", align); 1183 #endif 1184 1185 args_n_results[nargs + 1] = 1186 uvm_pglistalloc(size, low, high, align, 0, &alloclist, 1, 0); 1187 #if 0 1188 printf(" -> 0x%lx", args_n_results[nargs + 1]); 1189 #endif 1190 if (args_n_results[nargs + 1] != 0) { 1191 #if 0 1192 printf("(failed)\n"); 1193 #endif 1194 args_n_results[nargs + 1] = -1; 1195 args->nreturns = 2; 1196 return; 1197 } 1198 args_n_results[nargs + 2] = VM_PAGE_TO_PHYS(alloclist.tqh_first); 1199 #if 0 1200 printf("(succeeded: pa = 0x%lx)\n", args_n_results[nargs + 2]); 1201 #endif 1202 args->nreturns = 3; 1203 1204 } else if (strcmp(name, "release-phys") == 0) { 1205 printf("unimplemented ofw callback - %s\n", name); 1206 args_n_results[nargs] = -1; 1207 args->nreturns = 1; 1208 } else if (strcmp(name, "claim-virt") == 0) { 1209 vaddr_t va; 1210 vaddr_t align; 1211 1212 /* XXX - notyet */ 1213 /* printf("unimplemented ofw callback - %s\n", name);*/ 1214 args_n_results[nargs] = -1; 1215 args->nreturns = 1; 1216 return; 1217 1218 /* Check format. */ 1219 if (nargs != 2 || nreturns < 3) { 1220 args_n_results[nargs] = -1; 1221 args->nreturns = 1; 1222 return; 1223 } 1224 args_n_results[nargs] = 0; /* properly formatted request */ 1225 1226 /* Allocate size bytes with specified alignment. */ 1227 align = (vaddr_t)args_n_results[1]; 1228 if (align % PAGE_SIZE != 0) { 1229 args_n_results[nargs + 1] = -1; 1230 args->nreturns = 2; 1231 return; 1232 } 1233 1234 if (va == 0) { 1235 /* Couldn't allocate. */ 1236 args_n_results[nargs + 1] = -1; 1237 args->nreturns = 2; 1238 } else { 1239 /* Successful allocation. */ 1240 args_n_results[nargs + 1] = 0; 1241 args_n_results[nargs + 2] = va; 1242 args->nreturns = 3; 1243 } 1244 } else if (strcmp(name, "release-virt") == 0) { 1245 1246 /* XXX - notyet */ 1247 printf("unimplemented ofw callback - %s\n", name); 1248 args_n_results[nargs] = -1; 1249 args->nreturns = 1; 1250 return; 1251 1252 /* Check format. */ 1253 if (nargs != 2 || nreturns < 1) { 1254 args_n_results[nargs] = -1; 1255 args->nreturns = 1; 1256 return; 1257 } 1258 args_n_results[nargs] = 0; /* properly formatted request */ 1259 1260 args->nreturns = 1; 1261 } else { 1262 args_n_results[nargs] = -1; 1263 args->nreturns = 1; 1264 } 1265 } 1266 1267 static void 1268 ofw_construct_proc0_addrspace(void) 1269 { 1270 int i, oft; 1271 static pv_addr_t proc0_pt_sys; 1272 static pv_addr_t proc0_pt_kernel[KERNEL_IMG_PTS]; 1273 static pv_addr_t proc0_pt_vmdata[KERNEL_VMDATA_PTS]; 1274 static pv_addr_t proc0_pt_ofw[KERNEL_OFW_PTS]; 1275 static pv_addr_t proc0_pt_io[KERNEL_IO_PTS]; 1276 static pv_addr_t msgbuf; 1277 vaddr_t L1pagetable; 1278 struct mem_translation *tp; 1279 1280 /* Set-up the system page. */ 1281 KASSERT(vector_page == 0); /* XXX for now */ 1282 systempage.pv_va = ofw_claimvirt(vector_page, PAGE_SIZE, 0); 1283 if (systempage.pv_va == -1) { 1284 /* Something was already mapped to vector_page's VA. */ 1285 systempage.pv_va = vector_page; 1286 systempage.pv_pa = ofw_gettranslation(vector_page); 1287 if (systempage.pv_pa == -1) 1288 panic("bogus result from gettranslation(vector_page)"); 1289 } else { 1290 /* We were just allocated the page-length range at VA 0. */ 1291 if (systempage.pv_va != vector_page) 1292 panic("bogus result from claimvirt(vector_page, PAGE_SIZE, 0)"); 1293 1294 /* Now allocate a physical page, and establish the mapping. */ 1295 systempage.pv_pa = ofw_claimphys(0, PAGE_SIZE, PAGE_SIZE); 1296 if (systempage.pv_pa == -1) 1297 panic("bogus result from claimphys(0, PAGE_SIZE, PAGE_SIZE)"); 1298 ofw_settranslation(systempage.pv_va, systempage.pv_pa, 1299 PAGE_SIZE, -1); /* XXX - mode? -JJK */ 1300 1301 /* Zero the memory. */ 1302 memset((char *)systempage.pv_va, 0, PAGE_SIZE); 1303 } 1304 1305 /* Allocate/initialize space for the proc0, NetBSD-managed */ 1306 /* page tables that we will be switching to soon. */ 1307 ofw_claimpages(&virt_freeptr, &kernel_l1pt, L1_TABLE_SIZE); 1308 ofw_claimpages(&virt_freeptr, &proc0_pt_sys, L2_TABLE_SIZE); 1309 for (i = 0; i < KERNEL_IMG_PTS; i++) 1310 ofw_claimpages(&virt_freeptr, &proc0_pt_kernel[i], L2_TABLE_SIZE); 1311 for (i = 0; i < KERNEL_VMDATA_PTS; i++) 1312 ofw_claimpages(&virt_freeptr, &proc0_pt_vmdata[i], L2_TABLE_SIZE); 1313 for (i = 0; i < KERNEL_OFW_PTS; i++) 1314 ofw_claimpages(&virt_freeptr, &proc0_pt_ofw[i], L2_TABLE_SIZE); 1315 for (i = 0; i < KERNEL_IO_PTS; i++) 1316 ofw_claimpages(&virt_freeptr, &proc0_pt_io[i], L2_TABLE_SIZE); 1317 1318 /* Allocate/initialize space for stacks. */ 1319 #ifndef OFWGENCFG 1320 ofw_claimpages(&virt_freeptr, &irqstack, PAGE_SIZE); 1321 #endif 1322 ofw_claimpages(&virt_freeptr, &undstack, PAGE_SIZE); 1323 ofw_claimpages(&virt_freeptr, &abtstack, PAGE_SIZE); 1324 ofw_claimpages(&virt_freeptr, &kernelstack, UPAGES * PAGE_SIZE); 1325 1326 /* Allocate/initialize space for msgbuf area. */ 1327 ofw_claimpages(&virt_freeptr, &msgbuf, MSGBUFSIZE); 1328 msgbufphys = msgbuf.pv_pa; 1329 1330 /* Construct the proc0 L1 pagetable. */ 1331 L1pagetable = kernel_l1pt.pv_va; 1332 1333 pmap_link_l2pt(L1pagetable, 0x0, &proc0_pt_sys); 1334 for (i = 0; i < KERNEL_IMG_PTS; i++) 1335 pmap_link_l2pt(L1pagetable, KERNEL_BASE + i * 0x00400000, 1336 &proc0_pt_kernel[i]); 1337 for (i = 0; i < KERNEL_VMDATA_PTS; i++) 1338 pmap_link_l2pt(L1pagetable, KERNEL_VM_BASE + i * 0x00400000, 1339 &proc0_pt_vmdata[i]); 1340 for (i = 0; i < KERNEL_OFW_PTS; i++) 1341 pmap_link_l2pt(L1pagetable, OFW_VIRT_BASE + i * 0x00400000, 1342 &proc0_pt_ofw[i]); 1343 for (i = 0; i < KERNEL_IO_PTS; i++) 1344 pmap_link_l2pt(L1pagetable, IO_VIRT_BASE + i * 0x00400000, 1345 &proc0_pt_io[i]); 1346 1347 /* 1348 * OK, we're done allocating. 1349 * Get a dump of OFW's translations, and make the appropriate 1350 * entries in the L2 pagetables that we just allocated. 1351 */ 1352 1353 ofw_getvirttranslations(); 1354 1355 for (oft = 0, tp = OFtranslations; oft < nOFtranslations; 1356 oft++, tp++) { 1357 1358 vaddr_t va; 1359 paddr_t pa; 1360 int npages = tp->size / PAGE_SIZE; 1361 1362 /* Size must be an integral number of pages. */ 1363 if (npages == 0 || tp->size % PAGE_SIZE != 0) 1364 panic("illegal ofw translation (size)"); 1365 1366 /* Make an entry for each page in the appropriate table. */ 1367 for (va = tp->virt, pa = tp->phys; npages > 0; 1368 va += PAGE_SIZE, pa += PAGE_SIZE, npages--) { 1369 /* 1370 * Map the top bits to the appropriate L2 pagetable. 1371 * The only allowable regions are page0, the 1372 * kernel-static area, and the ofw area. 1373 */ 1374 switch (va >> (L1_S_SHIFT + 2)) { 1375 case 0: 1376 /* page0 */ 1377 break; 1378 1379 #if KERNEL_IMG_PTS != 2 1380 #error "Update ofw translation range list" 1381 #endif 1382 case ( KERNEL_BASE >> (L1_S_SHIFT + 2)): 1383 case ((KERNEL_BASE + 0x00400000) >> (L1_S_SHIFT + 2)): 1384 /* kernel static area */ 1385 break; 1386 1387 case ( OFW_VIRT_BASE >> (L1_S_SHIFT + 2)): 1388 case ((OFW_VIRT_BASE + 0x00400000) >> (L1_S_SHIFT + 2)): 1389 case ((OFW_VIRT_BASE + 0x00800000) >> (L1_S_SHIFT + 2)): 1390 case ((OFW_VIRT_BASE + 0x00C00000) >> (L1_S_SHIFT + 2)): 1391 /* ofw area */ 1392 break; 1393 1394 case ( IO_VIRT_BASE >> (L1_S_SHIFT + 2)): 1395 case ((IO_VIRT_BASE + 0x00400000) >> (L1_S_SHIFT + 2)): 1396 case ((IO_VIRT_BASE + 0x00800000) >> (L1_S_SHIFT + 2)): 1397 case ((IO_VIRT_BASE + 0x00C00000) >> (L1_S_SHIFT + 2)): 1398 /* io area */ 1399 break; 1400 1401 default: 1402 /* illegal */ 1403 panic("illegal ofw translation (addr) %#lx", 1404 va); 1405 } 1406 1407 /* Make the entry. */ 1408 pmap_map_entry(L1pagetable, va, pa, 1409 VM_PROT_READ|VM_PROT_WRITE, 1410 (tp->mode & 0xC) == 0xC ? PTE_CACHE 1411 : PTE_NOCACHE); 1412 } 1413 } 1414 1415 /* 1416 * We don't actually want some of the mappings that we just 1417 * set up to appear in proc0's address space. In particular, 1418 * we don't want aliases to physical addresses that the kernel 1419 * has-mapped/will-map elsewhere. 1420 */ 1421 ofw_discardmappings(proc0_pt_kernel[KERNEL_IMG_PTS - 1].pv_va, 1422 msgbuf.pv_va, MSGBUFSIZE); 1423 1424 /* update the top of the kernel VM */ 1425 pmap_curmaxkvaddr = 1426 KERNEL_VM_BASE + (KERNEL_VMDATA_PTS * 0x00400000); 1427 1428 /* 1429 * gross hack for the sake of not thrashing the TLB and making 1430 * cache flush more efficient: blast l1 ptes for sections. 1431 */ 1432 for (oft = 0, tp = OFtranslations; oft < nOFtranslations; oft++, tp++) { 1433 vaddr_t va = tp->virt; 1434 paddr_t pa = tp->phys; 1435 1436 if (((va | pa) & L1_S_OFFSET) == 0) { 1437 int nsections = tp->size / L1_S_SIZE; 1438 1439 while (nsections--) { 1440 /* XXXJRT prot?? */ 1441 pmap_map_section(L1pagetable, va, pa, 1442 VM_PROT_READ|VM_PROT_WRITE, 1443 (tp->mode & 0xC) == 0xC ? PTE_CACHE 1444 : PTE_NOCACHE); 1445 va += L1_S_SIZE; 1446 pa += L1_S_SIZE; 1447 } 1448 } 1449 } 1450 } 1451 1452 1453 static void 1454 ofw_getphysmeminfo(void) 1455 { 1456 int phandle; 1457 int mem_len; 1458 int avail_len; 1459 int i; 1460 1461 if ((phandle = OF_finddevice("/memory")) == -1 || 1462 (mem_len = OF_getproplen(phandle, "reg")) <= 0 || 1463 (OFphysmem = (struct mem_region *)ofw_malloc(mem_len)) == 0 || 1464 OF_getprop(phandle, "reg", OFphysmem, mem_len) != mem_len || 1465 (avail_len = OF_getproplen(phandle, "available")) <= 0 || 1466 (OFphysavail = (struct mem_region *)ofw_malloc(avail_len)) == 0 || 1467 OF_getprop(phandle, "available", OFphysavail, avail_len) 1468 != avail_len) 1469 panic("can't get physmeminfo from OFW"); 1470 1471 nOFphysmem = mem_len / sizeof(struct mem_region); 1472 nOFphysavail = avail_len / sizeof(struct mem_region); 1473 1474 /* 1475 * Sort the blocks in each array into ascending address order. 1476 * Also, page-align all blocks. 1477 */ 1478 for (i = 0; i < 2; i++) { 1479 struct mem_region *tmp = (i == 0) ? OFphysmem : OFphysavail; 1480 struct mem_region *mp; 1481 int cnt = (i == 0) ? nOFphysmem : nOFphysavail; 1482 int j; 1483 1484 #ifdef OLDPRINTFS 1485 printf("ofw_getphysmeminfo: %d blocks\n", cnt); 1486 #endif 1487 1488 /* XXX - Convert all the values to host order. -JJK */ 1489 for (j = 0, mp = tmp; j < cnt; j++, mp++) { 1490 mp->start = of_decode_int((unsigned char *)&mp->start); 1491 mp->size = of_decode_int((unsigned char *)&mp->size); 1492 } 1493 1494 for (j = 0, mp = tmp; j < cnt; j++, mp++) { 1495 u_int s, sz; 1496 struct mem_region *mp1; 1497 1498 /* Page-align start of the block. */ 1499 s = mp->start % PAGE_SIZE; 1500 if (s != 0) { 1501 s = (PAGE_SIZE - s); 1502 1503 if (mp->size >= s) { 1504 mp->start += s; 1505 mp->size -= s; 1506 } 1507 } 1508 1509 /* Page-align the size. */ 1510 mp->size -= mp->size % PAGE_SIZE; 1511 1512 /* Handle empty block. */ 1513 if (mp->size == 0) { 1514 memmove(mp, mp + 1, (cnt - (mp - tmp)) 1515 * sizeof(struct mem_region)); 1516 cnt--; 1517 mp--; 1518 continue; 1519 } 1520 1521 /* Bubble sort. */ 1522 s = mp->start; 1523 sz = mp->size; 1524 for (mp1 = tmp; mp1 < mp; mp1++) 1525 if (s < mp1->start) 1526 break; 1527 if (mp1 < mp) { 1528 memmove(mp1 + 1, mp1, (char *)mp - (char *)mp1); 1529 mp1->start = s; 1530 mp1->size = sz; 1531 } 1532 } 1533 1534 #ifdef OLDPRINTFS 1535 for (mp = tmp; mp->size; mp++) { 1536 printf("%lx, %lx\n", mp->start, mp->size); 1537 } 1538 #endif 1539 } 1540 } 1541 1542 1543 static void 1544 ofw_getvirttranslations(void) 1545 { 1546 int mmu_phandle; 1547 int mmu_ihandle; 1548 int trans_len; 1549 int over, len; 1550 int i; 1551 struct mem_translation *tp; 1552 1553 mmu_ihandle = ofw_mmu_ihandle(); 1554 1555 /* overallocate to avoid increases during allocation */ 1556 over = 4 * sizeof(struct mem_translation); 1557 if ((mmu_phandle = OF_instance_to_package(mmu_ihandle)) == -1 || 1558 (len = OF_getproplen(mmu_phandle, "translations")) <= 0 || 1559 (OFtranslations = ofw_malloc(len + over)) == 0 || 1560 (trans_len = OF_getprop(mmu_phandle, "translations", 1561 OFtranslations, len + over)) > (len + over)) 1562 panic("can't get virttranslations from OFW"); 1563 1564 /* XXX - Convert all the values to host order. -JJK */ 1565 nOFtranslations = trans_len / sizeof(struct mem_translation); 1566 #ifdef OLDPRINTFS 1567 printf("ofw_getvirtmeminfo: %d blocks\n", nOFtranslations); 1568 #endif 1569 for (i = 0, tp = OFtranslations; i < nOFtranslations; i++, tp++) { 1570 tp->virt = of_decode_int((unsigned char *)&tp->virt); 1571 tp->size = of_decode_int((unsigned char *)&tp->size); 1572 tp->phys = of_decode_int((unsigned char *)&tp->phys); 1573 tp->mode = of_decode_int((unsigned char *)&tp->mode); 1574 } 1575 } 1576 1577 /* 1578 * ofw_valloc: allocate blocks of VM for IO and other special purposes 1579 */ 1580 typedef struct _vfree { 1581 struct _vfree *pNext; 1582 vaddr_t start; 1583 vsize_t size; 1584 } VFREE, *PVFREE; 1585 1586 static VFREE vfinitial = { NULL, IO_VIRT_BASE, IO_VIRT_SIZE }; 1587 1588 static PVFREE vflist = &vfinitial; 1589 1590 static vaddr_t 1591 ofw_valloc(vsize_t size, vaddr_t align) 1592 { 1593 PVFREE *ppvf; 1594 PVFREE pNew; 1595 vaddr_t new; 1596 vaddr_t lead; 1597 1598 for (ppvf = &vflist; *ppvf; ppvf = &((*ppvf)->pNext)) { 1599 if (align == 0) { 1600 new = (*ppvf)->start; 1601 lead = 0; 1602 } else { 1603 new = ((*ppvf)->start + (align - 1)) & ~(align - 1); 1604 lead = new - (*ppvf)->start; 1605 } 1606 1607 if (((*ppvf)->size - lead) >= size) { 1608 if (lead == 0) { 1609 /* using whole block */ 1610 if (size == (*ppvf)->size) { 1611 /* splice out of list */ 1612 (*ppvf) = (*ppvf)->pNext; 1613 } else { /* tail of block is free */ 1614 (*ppvf)->start = new + size; 1615 (*ppvf)->size -= size; 1616 } 1617 } else { 1618 vsize_t tail = ((*ppvf)->start 1619 + (*ppvf)->size) - (new + size); 1620 /* free space at beginning */ 1621 (*ppvf)->size = lead; 1622 1623 if (tail != 0) { 1624 /* free space at tail */ 1625 pNew = ofw_malloc(sizeof(VFREE)); 1626 pNew->pNext = (*ppvf)->pNext; 1627 (*ppvf)->pNext = pNew; 1628 pNew->start = new + size; 1629 pNew->size = tail; 1630 } 1631 } 1632 return new; 1633 } /* END if */ 1634 } /* END for */ 1635 1636 return -1; 1637 } 1638 1639 vaddr_t 1640 ofw_map(paddr_t pa, vsize_t size, int cb_bits) 1641 { 1642 vaddr_t va; 1643 1644 if ((va = ofw_valloc(size, size)) == -1) 1645 panic("cannot alloc virtual memory for %#lx", pa); 1646 1647 ofw_claimvirt(va, size, 0); /* make sure OFW knows about the memory */ 1648 1649 ofw_settranslation(va, pa, size, L2_AP(AP_KRW) | cb_bits); 1650 1651 return va; 1652 } 1653 1654 static int 1655 ofw_mem_ihandle(void) 1656 { 1657 static int mem_ihandle = 0; 1658 int chosen; 1659 1660 if (mem_ihandle != 0) 1661 return(mem_ihandle); 1662 1663 if ((chosen = OF_finddevice("/chosen")) == -1 || 1664 OF_getprop(chosen, "memory", &mem_ihandle, sizeof(int)) < 0) 1665 panic("ofw_mem_ihandle"); 1666 1667 mem_ihandle = of_decode_int((unsigned char *)&mem_ihandle); 1668 1669 return(mem_ihandle); 1670 } 1671 1672 1673 static int 1674 ofw_mmu_ihandle(void) 1675 { 1676 static int mmu_ihandle = 0; 1677 int chosen; 1678 1679 if (mmu_ihandle != 0) 1680 return(mmu_ihandle); 1681 1682 if ((chosen = OF_finddevice("/chosen")) == -1 || 1683 OF_getprop(chosen, "mmu", &mmu_ihandle, sizeof(int)) < 0) 1684 panic("ofw_mmu_ihandle"); 1685 1686 mmu_ihandle = of_decode_int((unsigned char *)&mmu_ihandle); 1687 1688 return(mmu_ihandle); 1689 } 1690 1691 1692 /* Return -1 on failure. */ 1693 static paddr_t 1694 ofw_claimphys(paddr_t pa, psize_t size, paddr_t align) 1695 { 1696 int mem_ihandle = ofw_mem_ihandle(); 1697 1698 /* printf("ofw_claimphys (%x, %x, %x) --> ", pa, size, align);*/ 1699 if (align == 0) { 1700 /* Allocate at specified base; alignment is ignored. */ 1701 pa = OF_call_method_1("claim", mem_ihandle, 3, pa, size, align); 1702 } else { 1703 /* Allocate anywhere, with specified alignment. */ 1704 pa = OF_call_method_1("claim", mem_ihandle, 2, size, align); 1705 } 1706 1707 /* printf("%x\n", pa);*/ 1708 return(pa); 1709 } 1710 1711 1712 #if 0 1713 /* Return -1 on failure. */ 1714 static paddr_t 1715 ofw_releasephys(paddr_t pa, psize_t size) 1716 { 1717 int mem_ihandle = ofw_mem_ihandle(); 1718 1719 /* printf("ofw_releasephys (%x, %x)\n", pa, size);*/ 1720 1721 return (OF_call_method_1("release", mem_ihandle, 2, pa, size)); 1722 } 1723 #endif 1724 1725 /* Return -1 on failure. */ 1726 static vaddr_t 1727 ofw_claimvirt(vaddr_t va, vsize_t size, vaddr_t align) 1728 { 1729 int mmu_ihandle = ofw_mmu_ihandle(); 1730 1731 /*printf("ofw_claimvirt (%x, %x, %x) --> ", va, size, align);*/ 1732 if (align == 0) { 1733 /* Allocate at specified base; alignment is ignored. */ 1734 va = OF_call_method_1("claim", mmu_ihandle, 3, va, size, align); 1735 } else { 1736 /* Allocate anywhere, with specified alignment. */ 1737 va = OF_call_method_1("claim", mmu_ihandle, 2, size, align); 1738 } 1739 1740 /*printf("%x\n", va);*/ 1741 return(va); 1742 } 1743 1744 /* Return -1 if no mapping. */ 1745 paddr_t 1746 ofw_gettranslation(vaddr_t va) 1747 { 1748 int mmu_ihandle = ofw_mmu_ihandle(); 1749 paddr_t pa; 1750 int mode; 1751 int exists; 1752 1753 #ifdef OFW_DEBUG 1754 printf("ofw_gettranslation (%x) --> ", (uint32_t)va); 1755 #endif 1756 exists = 0; /* gets set to true if translation exists */ 1757 if (OF_call_method("translate", mmu_ihandle, 1, 3, va, &pa, &mode, 1758 &exists) != 0) { 1759 #ifdef OFW_DEBUG 1760 printf("(failed)\n"); 1761 #endif 1762 return(-1); 1763 } 1764 1765 #ifdef OFW_DEBUG 1766 printf("%d %x\n", exists, (uint32_t)pa); 1767 #endif 1768 return(exists ? pa : -1); 1769 } 1770 1771 1772 static void 1773 ofw_settranslation(vaddr_t va, paddr_t pa, vsize_t size, int mode) 1774 { 1775 int mmu_ihandle = ofw_mmu_ihandle(); 1776 1777 #ifdef OFW_DEBUG 1778 printf("ofw_settranslation (%x, %x, %x, %x) --> void\n", (uint32_t)va, 1779 (uint32_t)pa, (uint32_t)size, (uint32_t)mode); 1780 #endif 1781 if (OF_call_method("map", mmu_ihandle, 4, 0, pa, va, size, mode) != 0) 1782 panic("ofw_settranslation failed"); 1783 } 1784 1785 /* 1786 * Allocation routine used before the kernel takes over memory. 1787 * Use this for efficient storage for things that aren't rounded to 1788 * page size. 1789 * 1790 * The point here is not necessarily to be very efficient (even though 1791 * that's sort of nice), but to do proper dynamic allocation to avoid 1792 * size-limitation errors. 1793 * 1794 */ 1795 1796 typedef struct _leftover { 1797 struct _leftover *pNext; 1798 vsize_t size; 1799 } LEFTOVER, *PLEFTOVER; 1800 1801 /* leftover bits of pages. first word is pointer to next. 1802 second word is size of leftover */ 1803 static PLEFTOVER leftovers = NULL; 1804 1805 static void * 1806 ofw_malloc(vsize_t size) 1807 { 1808 PLEFTOVER *ppLeftover; 1809 PLEFTOVER pLeft; 1810 pv_addr_t new; 1811 vsize_t newSize, claim_size; 1812 1813 /* round and set minimum size */ 1814 size = uimax(sizeof(LEFTOVER), 1815 ((size + (sizeof(LEFTOVER) - 1)) & ~(sizeof(LEFTOVER) - 1))); 1816 1817 for (ppLeftover = &leftovers; *ppLeftover; 1818 ppLeftover = &((*ppLeftover)->pNext)) 1819 if ((*ppLeftover)->size >= size) 1820 break; 1821 1822 if (*ppLeftover) { /* have a leftover of the right size */ 1823 /* remember the leftover */ 1824 new.pv_va = (vaddr_t)*ppLeftover; 1825 if ((*ppLeftover)->size < (size + sizeof(LEFTOVER))) { 1826 /* splice out of chain */ 1827 *ppLeftover = (*ppLeftover)->pNext; 1828 } else { 1829 /* remember the next pointer */ 1830 pLeft = (*ppLeftover)->pNext; 1831 newSize = (*ppLeftover)->size - size; /* reduce size */ 1832 /* move pointer */ 1833 *ppLeftover = (PLEFTOVER)(((vaddr_t)*ppLeftover) 1834 + size); 1835 (*ppLeftover)->pNext = pLeft; 1836 (*ppLeftover)->size = newSize; 1837 } 1838 } else { 1839 claim_size = (size + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1); 1840 ofw_claimpages(&virt_freeptr, &new, claim_size); 1841 if ((size + sizeof(LEFTOVER)) <= claim_size) { 1842 pLeft = (PLEFTOVER)(new.pv_va + size); 1843 pLeft->pNext = leftovers; 1844 pLeft->size = claim_size - size; 1845 leftovers = pLeft; 1846 } 1847 } 1848 1849 return (void *)(new.pv_va); 1850 } 1851 1852 /* 1853 * Here is a really, really sleazy free. It's not used right now, 1854 * because it's not worth the extra complexity for just a few bytes. 1855 * 1856 */ 1857 #if 0 1858 static void 1859 ofw_free(vaddr_t addr, vsize_t size) 1860 { 1861 PLEFTOVER pLeftover = (PLEFTOVER)addr; 1862 1863 /* splice right into list without checks or compaction */ 1864 pLeftover->pNext = leftovers; 1865 pLeftover->size = size; 1866 leftovers = pLeftover; 1867 } 1868 #endif 1869 1870 /* 1871 * Allocate and zero round(size)/PAGE_SIZE pages of memory. 1872 * We guarantee that the allocated memory will be 1873 * aligned to a boundary equal to the smallest power of 1874 * 2 greater than or equal to size. 1875 * free_pp is an IN/OUT parameter which points to the 1876 * last allocated virtual address in an allocate-downwards 1877 * stack. pv_p is an OUT parameter which contains the 1878 * virtual and physical base addresses of the allocated 1879 * memory. 1880 */ 1881 static void 1882 ofw_claimpages(vaddr_t *free_pp, pv_addr_t *pv_p, vsize_t size) 1883 { 1884 /* round-up to page boundary */ 1885 vsize_t alloc_size = (size + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1); 1886 vsize_t aligned_size; 1887 vaddr_t va; 1888 paddr_t pa; 1889 1890 if (alloc_size == 0) 1891 panic("ofw_claimpages zero"); 1892 1893 for (aligned_size = 1; aligned_size < alloc_size; aligned_size <<= 1) 1894 ; 1895 1896 /* The only way to provide the alignment guarantees is to 1897 * allocate the virtual and physical ranges separately, 1898 * then do an explicit map call. 1899 */ 1900 va = (*free_pp & ~(aligned_size - 1)) - aligned_size; 1901 if (ofw_claimvirt(va, alloc_size, 0) != va) 1902 panic("ofw_claimpages va alloc"); 1903 pa = ofw_claimphys(0, alloc_size, aligned_size); 1904 if (pa == -1) 1905 panic("ofw_claimpages pa alloc"); 1906 /* XXX - what mode? -JJK */ 1907 ofw_settranslation(va, pa, alloc_size, -1); 1908 1909 /* The memory's mapped-in now, so we can zero it. */ 1910 memset((char *)va, 0, alloc_size); 1911 1912 /* Set OUT parameters. */ 1913 *free_pp = va; 1914 pv_p->pv_va = va; 1915 pv_p->pv_pa = pa; 1916 } 1917 1918 1919 static void 1920 ofw_discardmappings(vaddr_t L2pagetable, vaddr_t va, vsize_t size) 1921 { 1922 /* round-up to page boundary */ 1923 vsize_t alloc_size = (size + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1); 1924 int npages = alloc_size / PAGE_SIZE; 1925 1926 if (npages == 0) 1927 panic("ofw_discardmappings zero"); 1928 1929 /* Discard each mapping. */ 1930 for (; npages > 0; va += PAGE_SIZE, npages--) { 1931 /* Sanity. The current entry should be non-null. */ 1932 if (ReadWord(L2pagetable + ((va >> 10) & 0x00000FFC)) == 0) 1933 panic("ofw_discardmappings zero entry"); 1934 1935 /* Clear the entry. */ 1936 WriteWord(L2pagetable + ((va >> 10) & 0x00000FFC), 0); 1937 } 1938 } 1939 1940 1941 static void 1942 ofw_initallocator(void) 1943 { 1944 1945 } 1946 1947 #if (NIGSFB_OFBUS > 0) || (NCHIPSFB_OFBUS > 0) || (NVGA_OFBUS > 0) 1948 static void 1949 reset_screen(void) 1950 { 1951 1952 if ((console_ihandle == 0) || (console_ihandle == -1)) 1953 return; 1954 1955 OF_call_method("install", console_ihandle, 0, 0); 1956 } 1957 #endif /* (NIGSFB_OFBUS > 0) || (NVGA_OFBUS > 0) */ 1958
Indexes created Sat Sep 20 22:09:52 GMT 2025