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