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
openfirmware(void * args)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
ofw_init(ofw_handle_t ofw_handle)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
ofw_boot(int howto,char * bootstr)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
get_fw_dhcp_data(struct bootdata * bdp)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
ofw_getbootinfo(char ** bp_pp,char ** ba_pp)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
ofw_getcleaninfo(void)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
ofw_configisa(paddr_t * pio,paddr_t * pmem)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
ofw_configisaonly(paddr_t * pio,paddr_t * pmem)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
ofw_configvl(int vl,paddr_t * pio,paddr_t * pmem)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
ofw_configisadma(paddr_t * pdma)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
ofw_configmem(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
ofw_callbackhandler(void * v)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
ofw_construct_proc0_addrspace(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
ofw_getphysmeminfo(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
ofw_getvirttranslations(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
ofw_valloc(vsize_t size,vaddr_t align)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
ofw_map(paddr_t pa,vsize_t size,int cb_bits)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
ofw_mem_ihandle(void)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
ofw_mmu_ihandle(void)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
ofw_claimphys(paddr_t pa,psize_t size,paddr_t align)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
ofw_claimvirt(vaddr_t va,vsize_t size,vaddr_t align)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
ofw_gettranslation(vaddr_t va)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
ofw_settranslation(vaddr_t va,paddr_t pa,vsize_t size,int mode)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 *
ofw_malloc(vsize_t size)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
ofw_claimpages(vaddr_t * free_pp,pv_addr_t * pv_p,vsize_t size)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
ofw_discardmappings(vaddr_t L2pagetable,vaddr_t va,vsize_t size)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
ofw_initallocator(void)1942 ofw_initallocator(void)
1943 {
1944
1945 }
1946
1947 #if (NIGSFB_OFBUS > 0) || (NCHIPSFB_OFBUS > 0) || (NVGA_OFBUS > 0)
1948 static void
reset_screen(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