machdep.c revision 1.13
1 /* $NetBSD: machdep.c,v 1.13 2003/07/15 01:37:35 lukem Exp $ */ 2 3 /* 4 * Copyright (C) 1995, 1996 Wolfgang Solfrank. 5 * Copyright (C) 1995, 1996 TooLs GmbH. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by TooLs GmbH. 19 * 4. The name of TooLs GmbH may not be used to endorse or promote products 20 * derived from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 27 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 28 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 29 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 30 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 31 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <sys/cdefs.h> 35 __KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.13 2003/07/15 01:37:35 lukem Exp $"); 36 37 #include "opt_marvell.h" 38 #include "opt_ev64260.h" 39 #include "opt_compat_netbsd.h" 40 #include "opt_ddb.h" 41 #include "opt_inet.h" 42 #include "opt_ccitt.h" 43 #include "opt_iso.h" 44 #include "opt_ns.h" 45 #include "opt_ipkdb.h" 46 47 #include <sys/param.h> 48 #include <sys/conf.h> 49 #include <sys/device.h> 50 #include <sys/kernel.h> 51 #include <sys/malloc.h> 52 #include <sys/mount.h> 53 #include <sys/msgbuf.h> 54 #include <sys/proc.h> 55 #include <sys/reboot.h> 56 #include <sys/extent.h> 57 #include <sys/syslog.h> 58 #include <sys/systm.h> 59 #include <sys/termios.h> 60 #include <sys/ksyms.h> 61 62 #include <uvm/uvm.h> 63 #include <uvm/uvm_extern.h> 64 65 #include <net/netisr.h> 66 67 #include <machine/bus.h> 68 #include <machine/db_machdep.h> 69 #include <machine/intr.h> 70 #include <machine/pmap.h> 71 #include <machine/powerpc.h> 72 #include <machine/trap.h> 73 74 #include <powerpc/oea/bat.h> 75 #include <powerpc/marvell/watchdog.h> 76 77 #include <ddb/db_extern.h> 78 79 #include <dev/cons.h> 80 81 #include "vga.h" 82 #if (NVGA > 0) 83 #include <dev/ic/mc6845reg.h> 84 #include <dev/ic/pcdisplayvar.h> 85 #include <dev/ic/vgareg.h> 86 #include <dev/ic/vgavar.h> 87 #endif 88 89 #include "isa.h" 90 #if (NISA > 0) 91 void isa_intr_init(void); 92 #endif 93 94 #include "pckbc.h" 95 #if (NPCKBC > 0) 96 #include <dev/isa/isareg.h> 97 #include <dev/ic/i8042reg.h> 98 #include <dev/ic/pckbcvar.h> 99 #endif 100 101 #include "com.h" 102 #if (NCOM > 0) 103 #include <dev/ic/comreg.h> 104 #include <dev/ic/comvar.h> 105 #endif 106 107 #include <dev/marvell/gtreg.h> 108 #include <dev/marvell/gtvar.h> 109 #include <dev/marvell/gtethreg.h> 110 111 #include "gtmpsc.h" 112 #if (NGTMPSC > 0) 113 #include <dev/marvell/gtsdmareg.h> 114 #include <dev/marvell/gtmpscreg.h> 115 #include <dev/marvell/gtmpscvar.h> 116 #endif 117 118 #include "ksyms.h" 119 120 /* 121 * Global variables used here and there 122 */ 123 extern struct user *proc0paddr; 124 125 #define PMONMEMREGIONS 32 126 struct mem_region physmemr[PMONMEMREGIONS], availmemr[PMONMEMREGIONS]; 127 128 char *bootpath; 129 130 void initppc(u_int, u_int, u_int, void *); /* Called from locore */ 131 void strayintr(int); 132 int lcsplx(int); 133 void gt_bus_space_init(void); 134 void gt_find_memory(bus_space_tag_t, bus_space_handle_t, paddr_t); 135 void gt_halt(bus_space_tag_t, bus_space_handle_t); 136 void return_to_dink(int); 137 void calc_delayconst(void); 138 139 void kcomcnputs(dev_t, const char *); 140 141 struct powerpc_bus_space gt_pci0_mem_bs_tag = { 142 _BUS_SPACE_LITTLE_ENDIAN|_BUS_SPACE_MEM_TYPE, 143 0x00000000, 0x00000000, 0x00000000, 144 }; 145 struct powerpc_bus_space gt_pci0_io_bs_tag = { 146 _BUS_SPACE_LITTLE_ENDIAN|_BUS_SPACE_IO_TYPE, 147 0x00000000, 0x00000000, 0x00000000, 148 }; 149 struct powerpc_bus_space gt_pci1_mem_bs_tag = { 150 _BUS_SPACE_LITTLE_ENDIAN|_BUS_SPACE_MEM_TYPE, 151 0x00000000, 0x00000000, 0x00000000, 152 }; 153 struct powerpc_bus_space gt_pci1_io_bs_tag = { 154 _BUS_SPACE_LITTLE_ENDIAN|_BUS_SPACE_IO_TYPE, 155 0x00000000, 0x00000000, 0x00000000, 156 }; 157 struct powerpc_bus_space gt_obio0_bs_tag = { 158 _BUS_SPACE_BIG_ENDIAN|_BUS_SPACE_MEM_TYPE|OBIO0_STRIDE, 159 0x00000000, 0x00000000, 0x00000000, 160 }; 161 struct powerpc_bus_space gt_obio1_bs_tag = { 162 _BUS_SPACE_BIG_ENDIAN|_BUS_SPACE_MEM_TYPE|OBIO1_STRIDE, 163 0x00000000, 0x00000000, 0x00000000, 164 }; 165 struct powerpc_bus_space gt_obio2_bs_tag = { 166 _BUS_SPACE_BIG_ENDIAN|_BUS_SPACE_MEM_TYPE|OBIO2_STRIDE, 167 0x00000000, 0x00000000, 0x00000000, 168 }; 169 struct powerpc_bus_space gt_obio3_bs_tag = { 170 _BUS_SPACE_BIG_ENDIAN|_BUS_SPACE_MEM_TYPE|OBIO3_STRIDE, 171 0x00000000, 0x00000000, 0x00000000, 172 }; 173 struct powerpc_bus_space gt_bootcs_bs_tag = { 174 _BUS_SPACE_BIG_ENDIAN|_BUS_SPACE_MEM_TYPE, 175 0x00000000, 0x00000000, 0x00000000, 176 }; 177 struct powerpc_bus_space gt_mem_bs_tag = { 178 _BUS_SPACE_LITTLE_ENDIAN|_BUS_SPACE_MEM_TYPE, 179 GT_BASE, 0x00000000, 0x00010000, 180 }; 181 182 bus_space_handle_t gt_memh; 183 184 struct powerpc_bus_space *obio_bs_tags[5] = { 185 >_obio0_bs_tag, >_obio1_bs_tag, >_obio2_bs_tag, 186 >_obio3_bs_tag, >_bootcs_bs_tag 187 }; 188 189 static char ex_storage[10][EXTENT_FIXED_STORAGE_SIZE(8)] 190 __attribute__((aligned(8))); 191 192 const struct gt_decode_info { 193 bus_addr_t low_decode; 194 bus_addr_t high_decode; 195 } decode_regs[] = { 196 { GT_SCS0_Low_Decode, GT_SCS0_High_Decode }, 197 { GT_SCS1_Low_Decode, GT_SCS1_High_Decode }, 198 { GT_SCS2_Low_Decode, GT_SCS2_High_Decode }, 199 { GT_SCS3_Low_Decode, GT_SCS3_High_Decode }, 200 { GT_CS0_Low_Decode, GT_CS0_High_Decode }, 201 { GT_CS1_Low_Decode, GT_CS1_High_Decode }, 202 { GT_CS2_Low_Decode, GT_CS2_High_Decode }, 203 { GT_CS3_Low_Decode, GT_CS3_High_Decode }, 204 { GT_BootCS_Low_Decode, GT_BootCS_High_Decode }, 205 }; 206 207 void 208 initppc(startkernel, endkernel, args, btinfo) 209 u_int startkernel, endkernel, args; 210 void *btinfo; 211 { 212 oea_batinit(0xf0000000, BAT_BL_256M); 213 oea_init((void (*)(void))ext_intr); 214 215 calc_delayconst(); /* Set CPU clock */ 216 217 DELAY(100000); 218 219 gt_bus_space_init(); 220 gt_find_memory(>_mem_bs_tag, gt_memh, roundup(endkernel, PAGE_SIZE)); 221 gt_halt(>_mem_bs_tag, gt_memh); 222 223 /* 224 * Now that we known how much memory, reinit the bats. 225 */ 226 oea_batinit(0xf0000000, BAT_BL_256M); 227 228 consinit(); 229 230 #if (NISA > 0) 231 isa_intr_init(); 232 #endif 233 234 /* 235 * Set the page size. 236 */ 237 uvm_setpagesize(); 238 239 /* 240 * Initialize pmap module. 241 */ 242 pmap_bootstrap(startkernel, endkernel); 243 244 #if NKSYMS || defined(DDB) || defined(LKM) 245 { 246 extern void *startsym, *endsym; 247 ksyms_init((int)((u_int)endsym - (u_int)startsym), 248 startsym, endsym); 249 } 250 #endif 251 #ifdef IPKDB 252 /* 253 * Now trap to IPKDB 254 */ 255 ipkdb_init(); 256 if (boothowto & RB_KDB) 257 ipkdb_connect(0); 258 #endif 259 } 260 261 void 262 mem_regions(struct mem_region **mem, struct mem_region **avail) 263 { 264 *mem = physmemr; 265 *avail = availmemr; 266 } 267 268 static __inline void 269 gt_record_memory(int j, paddr_t start, paddr_t end, paddr_t endkernel) 270 { 271 physmemr[j].start = start; 272 physmemr[j].size = end - start; 273 if (start < endkernel) 274 start = endkernel; 275 availmemr[j].start = start; 276 availmemr[j].size = end - start; 277 } 278 279 void 280 gt_find_memory(bus_space_tag_t memt, bus_space_handle_t memh, 281 paddr_t endkernel) 282 { 283 paddr_t start, end; 284 int i, j = 0, first = 1; 285 286 /* 287 * Round kernel end to a page boundary. 288 */ 289 for (i = 0; i < 4; i++) { 290 paddr_t nstart, nend; 291 nstart = GT_LowAddr_GET(bus_space_read_4(>_mem_bs_tag, 292 gt_memh, decode_regs[i].low_decode)); 293 nend = GT_HighAddr_GET(bus_space_read_4(>_mem_bs_tag, 294 gt_memh, decode_regs[i].high_decode)) + 1; 295 if (nstart >= nend) 296 continue; 297 if (first) { 298 /* 299 * First entry? Just remember it. 300 */ 301 start = nstart; 302 end = nend; 303 first = 0; 304 } else if (nstart == end) { 305 /* 306 * Contiguous? Just update the end. 307 */ 308 end = nend; 309 } else { 310 /* 311 * Disjoint? record it. 312 */ 313 gt_record_memory(j, start, end, endkernel); 314 start = nstart; 315 end = nend; 316 j++; 317 } 318 } 319 gt_record_memory(j, start, end, endkernel); 320 } 321 322 /* 323 * Machine dependent startup code. 324 */ 325 void 326 cpu_startup(void) 327 { 328 register_t msr; 329 330 oea_startup(NULL); 331 332 /* 333 * Now that we have VM, malloc()s are OK in bus_space. 334 */ 335 bus_space_mallocok(); 336 337 /* 338 * Now allow hardware interrupts. 339 */ 340 splhigh(); 341 __asm __volatile ("mfmsr %0; ori %0,%0,%1; mtmsr %0" 342 : "=r"(msr) 343 : "K"(PSL_EE)); 344 } 345 346 /* 347 * consinit 348 * Initialize system console. 349 */ 350 void 351 consinit(void) 352 { 353 #ifdef MPSC_CONSOLE 354 /* PMON using MPSC0 @ 9600 */ 355 gtmpsccnattach(>_mem_bs_tag, gt_memh, MPSC_CONSOLE, 9600, 356 (TTYDEF_CFLAG & ~(CSIZE | CSTOPB | PARENB)) | CS8); 357 #else 358 /* PPCBOOT using COM1 @ 57600 */ 359 comcnattach(>_obio2_bs_tag, 0, 57600, 360 COM_FREQ*2, COM_TYPE_NORMAL, 361 (TTYDEF_CFLAG & ~(CSIZE | CSTOPB | PARENB)) | CS8); 362 #endif 363 } 364 365 #if (NPCKBC > 0) && (NPCKBD == 0) 366 /* 367 * glue code to support old console code with the 368 * mi keyboard controller driver 369 */ 370 int 371 pckbc_machdep_cnattach(pckbc_tag_t kbctag, pckbc_slot_t kbcslot) 372 { 373 #if (NPC > 0) 374 return (pcconskbd_cnattach(kbctag, kbcslot)); 375 #else 376 return (ENXIO); 377 #endif 378 } 379 #endif 380 381 /* 382 * Stray interrupts. 383 */ 384 void 385 strayintr(int irq) 386 { 387 log(LOG_ERR, "stray interrupt %d\n", irq); 388 } 389 390 /* 391 * Halt or reboot the machine after syncing/dumping according to howto. 392 */ 393 void 394 cpu_reboot(int howto, char *what) 395 { 396 static int syncing; 397 static char str[256]; 398 char *ap = str, *ap1 = ap; 399 400 boothowto = howto; 401 if (!cold && !(howto & RB_NOSYNC) && !syncing) { 402 syncing = 1; 403 vfs_shutdown(); /* sync */ 404 resettodr(); /* set wall clock */ 405 } 406 splhigh(); 407 if (howto & RB_HALT) { 408 doshutdownhooks(); 409 printf("halted\n\n"); 410 cnhalt(); 411 while(1); 412 } 413 if (!cold && (howto & RB_DUMP)) 414 oea_dumpsys(); 415 doshutdownhooks(); 416 printf("rebooting\n\n"); 417 if (what && *what) { 418 if (strlen(what) > sizeof str - 5) 419 printf("boot string too large, ignored\n"); 420 else { 421 strcpy(str, what); 422 ap1 = ap = str + strlen(str); 423 *ap++ = ' '; 424 } 425 } 426 *ap++ = '-'; 427 if (howto & RB_SINGLE) 428 *ap++ = 's'; 429 if (howto & RB_KDB) 430 *ap++ = 'd'; 431 *ap++ = 0; 432 if (ap[-2] == '-') 433 *ap1 = 0; 434 #if 0 435 { 436 void mvpppc_reboot(void); 437 mvpppc_reboot(); 438 } 439 #endif 440 gt_watchdog_reset(); 441 /* NOTREACHED */ 442 while (1); 443 } 444 445 int 446 lcsplx(int ipl) 447 { 448 return spllower(ipl); 449 } 450 451 void 452 gt_halt(bus_space_tag_t gt_memt, bus_space_handle_t gt_memh) 453 { 454 int i; 455 u_int32_t data; 456 457 /* 458 * Shut down the MPSC ports 459 */ 460 for (i = 0; i < 2; i++) { 461 bus_space_write_4(gt_memt, gt_memh, 462 SDMA_U_SDCM(i), SDMA_SDCM_AR|SDMA_SDCM_AT); 463 for (;;) { 464 data = bus_space_read_4(gt_memt, gt_memh, 465 SDMA_U_SDCM(i)); 466 if (((SDMA_SDCM_AR|SDMA_SDCM_AT) & data) == 0) 467 break; 468 } 469 } 470 471 /* 472 * Shut down the Ethernets 473 */ 474 for (i = 0; i < 3; i++) { 475 bus_space_write_4(gt_memt, gt_memh, 476 ETH_ESDCMR(2), ETH_ESDCMR_AR|ETH_ESDCMR_AT); 477 for (;;) { 478 data = bus_space_read_4(gt_memt, gt_memh, 479 ETH_ESDCMR(i)); 480 if (((ETH_ESDCMR_AR|ETH_ESDCMR_AT) & data) == 0) 481 break; 482 } 483 data = bus_space_read_4(gt_memt, gt_memh, ETH_EPCR(i)); 484 data &= ~ETH_EPCR_EN; 485 bus_space_write_4(gt_memt, gt_memh, ETH_EPCR(i), data); 486 } 487 } 488 489 int 490 gtget_macaddr(struct gt_softc *gt, int macno, char *enaddr) 491 { 492 enaddr[0] = 0x02; 493 enaddr[1] = 0x00; 494 enaddr[2] = 0x04; 495 enaddr[3] = 0x00; 496 enaddr[4] = 0x00; 497 enaddr[5] = 0x04 + macno; 498 499 return 0; 500 } 501 502 void 503 gt_bus_space_init(void) 504 { 505 bus_space_tag_t gt_memt = >_mem_bs_tag; 506 const struct gt_decode_info *di; 507 uint32_t datal, datah; 508 int error; 509 int bs = 0; 510 int j; 511 512 error = bus_space_init(>_mem_bs_tag, "gtmem", 513 ex_storage[bs], sizeof(ex_storage[bs])); 514 515 error = bus_space_map(gt_memt, 0, 0x10000, 0, >_memh); 516 517 for (j = 0, di = &decode_regs[4]; j < 5; j++, di++) { 518 struct powerpc_bus_space *memt = obio_bs_tags[j]; 519 datal = bus_space_read_4(gt_memt, gt_memh, di->low_decode); 520 datah = bus_space_read_4(gt_memt, gt_memh, di->high_decode); 521 522 if (GT_LowAddr_GET(datal) >= GT_HighAddr_GET(datal)) { 523 obio_bs_tags[j] = NULL; 524 continue; 525 } 526 memt->pbs_offset = GT_LowAddr_GET(datal); 527 memt->pbs_limit = GT_HighAddr_GET(datah) + 1 - 528 memt->pbs_offset; 529 530 error = bus_space_init(memt, "obio2", 531 ex_storage[bs], sizeof(ex_storage[bs])); 532 bs++; 533 } 534 535 datal = bus_space_read_4(gt_memt, gt_memh, GT_PCI0_Mem0_Low_Decode); 536 datah = bus_space_read_4(gt_memt, gt_memh, GT_PCI0_Mem0_High_Decode); 537 #if defined(GT_PCI0_MEMBASE) 538 datal &= ~0xfff; 539 datal |= (GT_PCI0_MEMBASE >> 20); 540 bus_space_write_4(gt_memt, gt_memh, GT_PCI0_Mem0_Low_Decode, datal); 541 #endif 542 #if defined(GT_PCI0_MEMSIZE) 543 datah &= ~0xfff; 544 datah |= (GT_PCI0_MEMSIZE + GT_LowAddr_GET(datal) - 1) >> 20; 545 bus_space_write_4(gt_memt, gt_memh, GT_PCI0_Mem0_High_Decode, datal); 546 #endif 547 gt_pci0_mem_bs_tag.pbs_base = GT_LowAddr_GET(datal); 548 gt_pci0_mem_bs_tag.pbs_limit = GT_HighAddr_GET(datah) + 1; 549 550 error = bus_space_init(>_pci0_mem_bs_tag, "pci0-mem", 551 ex_storage[bs], sizeof(ex_storage[bs])); 552 bs++; 553 554 /* 555 * Make sure PCI0 Memory is BAT mapped. 556 */ 557 if (GT_LowAddr_GET(datal) < GT_HighAddr_GET(datal)) 558 oea_iobat_add(gt_pci0_mem_bs_tag.pbs_base & SEGMENT_MASK, BAT_BL_256M); 559 560 /* 561 * Make sure that I/O space start at 0. 562 */ 563 bus_space_write_4(gt_memt, gt_memh, GT_PCI1_IO_Remap, 0); 564 565 datal = bus_space_read_4(gt_memt, gt_memh, GT_PCI0_IO_Low_Decode); 566 datah = bus_space_read_4(gt_memt, gt_memh, GT_PCI0_IO_High_Decode); 567 #if defined(GT_PCI0_IOBASE) 568 datal &= ~0xfff; 569 datal |= (GT_PCI0_IOBASE >> 20); 570 bus_space_write_4(gt_memt, gt_memh, GT_PCI0_IO_Low_Decode, datal); 571 #endif 572 #if defined(GT_PCI0_IOSIZE) 573 datah &= ~0xfff; 574 datah |= (GT_PCI0_IOSIZE + GT_LowAddr_GET(datal) - 1) >> 20; 575 bus_space_write_4(gt_memt, gt_memh, GT_PCI0_IO_High_Decode, datal); 576 #endif 577 gt_pci0_io_bs_tag.pbs_offset = GT_LowAddr_GET(datal); 578 gt_pci0_io_bs_tag.pbs_limit = GT_HighAddr_GET(datah) + 1 - 579 gt_pci0_io_bs_tag.pbs_offset; 580 581 error = bus_space_init(>_pci0_io_bs_tag, "pci0-ioport", 582 ex_storage[bs], sizeof(ex_storage[bs])); 583 bs++; 584 585 #if 0 586 error = extent_alloc_region(gt_pci0_io_bs_tag.pbs_extent, 587 0x10000, 0x7F0000, EX_NOWAIT); 588 if (error) 589 panic("gt_bus_space_init: can't block out reserved " 590 "I/O space 0x10000-0x7fffff: error=%d\n", error); 591 #endif 592 593 datal = bus_space_read_4(gt_memt, gt_memh, GT_PCI1_Mem0_Low_Decode); 594 datah = bus_space_read_4(gt_memt, gt_memh, GT_PCI1_Mem0_High_Decode); 595 #if defined(GT_PCI1_MEMBASE) 596 datal &= ~0xfff; 597 datal |= (GT_PCI1_MEMBASE >> 20); 598 bus_space_write_4(gt_memt, gt_memh, GT_PCI1_Mem0_Low_Decode, datal); 599 #endif 600 #if defined(GT_PCI1_MEMSIZE) 601 datah &= ~0xfff; 602 datah |= (GT_PCI1_MEMSIZE + GT_LowAddr_GET(datal) - 1) >> 20; 603 bus_space_write_4(gt_memt, gt_memh, GT_PCI1_Mem0_High_Decode, datal); 604 #endif 605 gt_pci1_mem_bs_tag.pbs_base = GT_LowAddr_GET(datal); 606 gt_pci1_mem_bs_tag.pbs_limit = GT_HighAddr_GET(datah) + 1; 607 608 error = bus_space_init(>_pci1_mem_bs_tag, "pci1-mem", 609 ex_storage[bs], sizeof(ex_storage[bs])); 610 bs++; 611 612 /* 613 * Make sure PCI1 Memory is BAT mapped. 614 */ 615 if (GT_LowAddr_GET(datal) < GT_HighAddr_GET(datal)) 616 oea_iobat_add(gt_pci1_mem_bs_tag.pbs_base & SEGMENT_MASK, BAT_BL_256M); 617 618 /* 619 * Make sure that I/O space start at 0. 620 */ 621 bus_space_write_4(gt_memt, gt_memh, GT_PCI1_IO_Remap, 0); 622 623 datal = bus_space_read_4(gt_memt, gt_memh, GT_PCI1_IO_Low_Decode); 624 datah = bus_space_read_4(gt_memt, gt_memh, GT_PCI1_IO_High_Decode); 625 #if defined(GT_PCI1_IOBASE) 626 datal &= ~0xfff; 627 datal |= (GT_PCI1_IOBASE >> 20); 628 bus_space_write_4(gt_memt, gt_memh, GT_PCI1_IO_Low_Decode, datal); 629 #endif 630 #if defined(GT_PCI1_IOSIZE) 631 datah &= ~0xfff; 632 datah |= (GT_PCI1_IOSIZE + GT_LowAddr_GET(datal) - 1) >> 20; 633 bus_space_write_4(gt_memt, gt_memh, GT_PCI1_IO_High_Decode, datal); 634 #endif 635 gt_pci1_io_bs_tag.pbs_offset = GT_LowAddr_GET(datal); 636 gt_pci1_io_bs_tag.pbs_limit = GT_HighAddr_GET(datah) + 1 - 637 gt_pci1_io_bs_tag.pbs_offset; 638 639 error = bus_space_init(>_pci1_io_bs_tag, "pci1-ioport", 640 ex_storage[bs], sizeof(ex_storage[bs])); 641 bs++; 642 643 #if 0 644 error = extent_alloc_region(gt_pci1_io_bs_tag.pbs_extent, 645 0x10000, 0x7F0000, EX_NOWAIT); 646 if (error) 647 panic("gt_bus_space_init: can't block out reserved " 648 "I/O space 0x10000-0x7fffff: error=%d\n", error); 649 #endif 650 } 651
Indexes created Tue Sep 30 11:09:46 GMT 2025