1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 1992, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2012 Garrett D'Amore <garrett@damore.org> 25 * Copyright 2014 Pluribus Networks, Inc. 26 * Copyright 2016 Nexenta Systems, Inc. 27 * Copyright 2018 Joyent, Inc. 28 */ 29 30 /* 31 * PC specific DDI implementation 32 */ 33 #include <sys/types.h> 34 #include <sys/autoconf.h> 35 #include <sys/avintr.h> 36 #include <sys/bootconf.h> 37 #include <sys/conf.h> 38 #include <sys/cpuvar.h> 39 #include <sys/ddi_impldefs.h> 40 #include <sys/ddi_subrdefs.h> 41 #include <sys/ethernet.h> 42 #include <sys/fp.h> 43 #include <sys/instance.h> 44 #include <sys/kmem.h> 45 #include <sys/machsystm.h> 46 #include <sys/modctl.h> 47 #include <sys/promif.h> 48 #include <sys/prom_plat.h> 49 #include <sys/sunndi.h> 50 #include <sys/ndi_impldefs.h> 51 #include <sys/ddi_impldefs.h> 52 #include <sys/sysmacros.h> 53 #include <sys/systeminfo.h> 54 #include <sys/utsname.h> 55 #include <sys/atomic.h> 56 #include <sys/spl.h> 57 #include <sys/archsystm.h> 58 #include <vm/seg_kmem.h> 59 #include <sys/ontrap.h> 60 #include <sys/fm/protocol.h> 61 #include <sys/ramdisk.h> 62 #include <sys/sunndi.h> 63 #include <sys/vmem.h> 64 #include <sys/pci_impl.h> 65 #if defined(__xpv) 66 #include <sys/hypervisor.h> 67 #endif 68 #include <sys/mach_intr.h> 69 #include <vm/hat_i86.h> 70 #include <sys/x86_archext.h> 71 #include <sys/avl.h> 72 #include <sys/font.h> 73 74 /* 75 * DDI Boot Configuration 76 */ 77 78 /* 79 * Platform drivers on this platform 80 */ 81 char *platform_module_list[] = { 82 "acpippm", 83 "ppm", 84 (char *)0 85 }; 86 87 /* pci bus resource maps */ 88 struct pci_bus_resource *pci_bus_res; 89 90 size_t dma_max_copybuf_size = 0x101000; /* 1M + 4K */ 91 92 uint64_t ramdisk_start, ramdisk_end; 93 94 int pseudo_isa = 0; 95 96 /* 97 * Forward declarations 98 */ 99 static int getlongprop_buf(); 100 static void get_boot_properties(void); 101 static void impl_bus_initialprobe(void); 102 static void impl_bus_reprobe(void); 103 104 static int poke_mem(peekpoke_ctlops_t *in_args); 105 static int peek_mem(peekpoke_ctlops_t *in_args); 106 107 static int kmem_override_cache_attrs(caddr_t, size_t, uint_t); 108 109 #if !defined(__xpv) 110 extern void immu_init(void); 111 #endif 112 113 /* 114 * We use an AVL tree to store contiguous address allocations made with the 115 * kalloca() routine, so that we can return the size to free with kfreea(). 116 * Note that in the future it would be vastly faster if we could eliminate 117 * this lookup by insisting that all callers keep track of their own sizes, 118 * just as for kmem_alloc(). 119 */ 120 struct ctgas { 121 avl_node_t ctg_link; 122 void *ctg_addr; 123 size_t ctg_size; 124 }; 125 126 static avl_tree_t ctgtree; 127 128 static kmutex_t ctgmutex; 129 #define CTGLOCK() mutex_enter(&ctgmutex) 130 #define CTGUNLOCK() mutex_exit(&ctgmutex) 131 132 /* 133 * Minimum pfn value of page_t's put on the free list. This is to simplify 134 * support of ddi dma memory requests which specify small, non-zero addr_lo 135 * values. 136 * 137 * The default value of 2, which corresponds to the only known non-zero addr_lo 138 * value used, means a single page will be sacrificed (pfn typically starts 139 * at 1). ddiphysmin can be set to 0 to disable. It cannot be set above 0x100 140 * otherwise mp startup panics. 141 */ 142 pfn_t ddiphysmin = 2; 143 144 static void 145 check_driver_disable(void) 146 { 147 int proplen = 128; 148 char *prop_name; 149 char *drv_name, *propval; 150 major_t major; 151 152 prop_name = kmem_alloc(proplen, KM_SLEEP); 153 for (major = 0; major < devcnt; major++) { 154 drv_name = ddi_major_to_name(major); 155 if (drv_name == NULL) 156 continue; 157 (void) snprintf(prop_name, proplen, "disable-%s", drv_name); 158 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(), 159 DDI_PROP_DONTPASS, prop_name, &propval) == DDI_SUCCESS) { 160 if (strcmp(propval, "true") == 0) { 161 devnamesp[major].dn_flags |= DN_DRIVER_REMOVED; 162 cmn_err(CE_NOTE, "driver %s disabled", 163 drv_name); 164 } 165 ddi_prop_free(propval); 166 } 167 } 168 kmem_free(prop_name, proplen); 169 } 170 171 172 /* 173 * Configure the hardware on the system. 174 * Called before the rootfs is mounted 175 */ 176 void 177 configure(void) 178 { 179 extern void i_ddi_init_root(); 180 181 extern int fpu_ignored; 182 183 /* 184 * Determine if an FPU is attached 185 */ 186 187 fpu_probe(); 188 189 190 if (fpu_ignored) { 191 printf("FP hardware will not be used\n"); 192 } else if (!fpu_exists) { 193 printf("No FPU in configuration\n"); 194 } 195 196 /* 197 * Initialize devices on the machine. 198 * Uses configuration tree built by the PROMs to determine what 199 * is present, and builds a tree of prototype dev_info nodes 200 * corresponding to the hardware which identified itself. 201 */ 202 203 /* 204 * Initialize root node. 205 */ 206 i_ddi_init_root(); 207 208 /* reprogram devices not set up by firmware (BIOS) */ 209 impl_bus_reprobe(); 210 211 #if !defined(__xpv) 212 /* 213 * Setup but don't startup the IOMMU 214 * Startup happens later via a direct call 215 * to IOMMU code by boot code. 216 * At this point, all PCI bus renumbering 217 * is done, so safe to init the IMMU 218 * AKA Intel IOMMU. 219 */ 220 immu_init(); 221 #endif 222 223 /* 224 * attach the isa nexus to get ACPI resource usage 225 * isa is "kind of" a pseudo node 226 */ 227 #if defined(__xpv) 228 if (DOMAIN_IS_INITDOMAIN(xen_info)) { 229 if (pseudo_isa) 230 (void) i_ddi_attach_pseudo_node("isa"); 231 else 232 (void) i_ddi_attach_hw_nodes("isa"); 233 } 234 #else 235 if (pseudo_isa) 236 (void) i_ddi_attach_pseudo_node("isa"); 237 else 238 (void) i_ddi_attach_hw_nodes("isa"); 239 #endif 240 } 241 242 /* 243 * The "status" property indicates the operational status of a device. 244 * If this property is present, the value is a string indicating the 245 * status of the device as follows: 246 * 247 * "okay" operational. 248 * "disabled" not operational, but might become operational. 249 * "fail" not operational because a fault has been detected, 250 * and it is unlikely that the device will become 251 * operational without repair. no additional details 252 * are available. 253 * "fail-xxx" not operational because a fault has been detected, 254 * and it is unlikely that the device will become 255 * operational without repair. "xxx" is additional 256 * human-readable information about the particular 257 * fault condition that was detected. 258 * 259 * The absence of this property means that the operational status is 260 * unknown or okay. 261 * 262 * This routine checks the status property of the specified device node 263 * and returns 0 if the operational status indicates failure, and 1 otherwise. 264 * 265 * The property may exist on plug-in cards the existed before IEEE 1275-1994. 266 * And, in that case, the property may not even be a string. So we carefully 267 * check for the value "fail", in the beginning of the string, noting 268 * the property length. 269 */ 270 int 271 status_okay(int id, char *buf, int buflen) 272 { 273 char status_buf[OBP_MAXPROPNAME]; 274 char *bufp = buf; 275 int len = buflen; 276 int proplen; 277 static const char *status = "status"; 278 static const char *fail = "fail"; 279 int fail_len = (int)strlen(fail); 280 281 /* 282 * Get the proplen ... if it's smaller than "fail", 283 * or doesn't exist ... then we don't care, since 284 * the value can't begin with the char string "fail". 285 * 286 * NB: proplen, if it's a string, includes the NULL in the 287 * the size of the property, and fail_len does not. 288 */ 289 proplen = prom_getproplen((pnode_t)id, (caddr_t)status); 290 if (proplen <= fail_len) /* nonexistant or uninteresting len */ 291 return (1); 292 293 /* 294 * if a buffer was provided, use it 295 */ 296 if ((buf == (char *)NULL) || (buflen <= 0)) { 297 bufp = status_buf; 298 len = sizeof (status_buf); 299 } 300 *bufp = (char)0; 301 302 /* 303 * Get the property into the buffer, to the extent of the buffer, 304 * and in case the buffer is smaller than the property size, 305 * NULL terminate the buffer. (This handles the case where 306 * a buffer was passed in and the caller wants to print the 307 * value, but the buffer was too small). 308 */ 309 (void) prom_bounded_getprop((pnode_t)id, (caddr_t)status, 310 (caddr_t)bufp, len); 311 *(bufp + len - 1) = (char)0; 312 313 /* 314 * If the value begins with the char string "fail", 315 * then it means the node is failed. We don't care 316 * about any other values. We assume the node is ok 317 * although it might be 'disabled'. 318 */ 319 if (strncmp(bufp, fail, fail_len) == 0) 320 return (0); 321 322 return (1); 323 } 324 325 /* 326 * Check the status of the device node passed as an argument. 327 * 328 * if ((status is OKAY) || (status is DISABLED)) 329 * return DDI_SUCCESS 330 * else 331 * print a warning and return DDI_FAILURE 332 */ 333 /*ARGSUSED1*/ 334 int 335 check_status(int id, char *name, dev_info_t *parent) 336 { 337 char status_buf[64]; 338 char devtype_buf[OBP_MAXPROPNAME]; 339 int retval = DDI_FAILURE; 340 341 /* 342 * is the status okay? 343 */ 344 if (status_okay(id, status_buf, sizeof (status_buf))) 345 return (DDI_SUCCESS); 346 347 /* 348 * a status property indicating bad memory will be associated 349 * with a node which has a "device_type" property with a value of 350 * "memory-controller". in this situation, return DDI_SUCCESS 351 */ 352 if (getlongprop_buf(id, OBP_DEVICETYPE, devtype_buf, 353 sizeof (devtype_buf)) > 0) { 354 if (strcmp(devtype_buf, "memory-controller") == 0) 355 retval = DDI_SUCCESS; 356 } 357 358 /* 359 * print the status property information 360 */ 361 cmn_err(CE_WARN, "status '%s' for '%s'", status_buf, name); 362 return (retval); 363 } 364 365 /*ARGSUSED*/ 366 uint_t 367 softlevel1(caddr_t arg1, caddr_t arg2) 368 { 369 softint(); 370 return (1); 371 } 372 373 /* 374 * Allow for implementation specific correction of PROM property values. 375 */ 376 377 /*ARGSUSED*/ 378 void 379 impl_fix_props(dev_info_t *dip, dev_info_t *ch_dip, char *name, int len, 380 caddr_t buffer) 381 { 382 /* 383 * There are no adjustments needed in this implementation. 384 */ 385 } 386 387 static int 388 getlongprop_buf(int id, char *name, char *buf, int maxlen) 389 { 390 int size; 391 392 size = prom_getproplen((pnode_t)id, name); 393 if (size <= 0 || (size > maxlen - 1)) 394 return (-1); 395 396 if (-1 == prom_getprop((pnode_t)id, name, buf)) 397 return (-1); 398 399 if (strcmp("name", name) == 0) { 400 if (buf[size - 1] != '\0') { 401 buf[size] = '\0'; 402 size += 1; 403 } 404 } 405 406 return (size); 407 } 408 409 static int 410 get_prop_int_array(dev_info_t *di, char *pname, int **pval, uint_t *plen) 411 { 412 int ret; 413 414 if ((ret = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, di, 415 DDI_PROP_DONTPASS, pname, pval, plen)) 416 == DDI_PROP_SUCCESS) { 417 *plen = (*plen) * (sizeof (int)); 418 } 419 return (ret); 420 } 421 422 423 /* 424 * Node Configuration 425 */ 426 427 struct prop_ispec { 428 uint_t pri, vec; 429 }; 430 431 /* 432 * For the x86, we're prepared to claim that the interrupt string 433 * is in the form of a list of <ipl,vec> specifications. 434 */ 435 436 #define VEC_MIN 1 437 #define VEC_MAX 255 438 439 static int 440 impl_xlate_intrs(dev_info_t *child, int *in, 441 struct ddi_parent_private_data *pdptr) 442 { 443 size_t size; 444 int n; 445 struct intrspec *new; 446 caddr_t got_prop; 447 int *inpri; 448 int got_len; 449 extern int ignore_hardware_nodes; /* force flag from ddi_impl.c */ 450 451 static char bad_intr_fmt[] = 452 "bad interrupt spec from %s%d - ipl %d, irq %d\n"; 453 454 /* 455 * determine if the driver is expecting the new style "interrupts" 456 * property which just contains the IRQ, or the old style which 457 * contains pairs of <IPL,IRQ>. if it is the new style, we always 458 * assign IPL 5 unless an "interrupt-priorities" property exists. 459 * in that case, the "interrupt-priorities" property contains the 460 * IPL values that match, one for one, the IRQ values in the 461 * "interrupts" property. 462 */ 463 inpri = NULL; 464 if ((ddi_getprop(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS, 465 "ignore-hardware-nodes", -1) != -1) || ignore_hardware_nodes) { 466 /* the old style "interrupts" property... */ 467 468 /* 469 * The list consists of <ipl,vec> elements 470 */ 471 if ((n = (*in++ >> 1)) < 1) 472 return (DDI_FAILURE); 473 474 pdptr->par_nintr = n; 475 size = n * sizeof (struct intrspec); 476 new = pdptr->par_intr = kmem_zalloc(size, KM_SLEEP); 477 478 while (n--) { 479 int level = *in++; 480 int vec = *in++; 481 482 if (level < 1 || level > MAXIPL || 483 vec < VEC_MIN || vec > VEC_MAX) { 484 cmn_err(CE_CONT, bad_intr_fmt, 485 DEVI(child)->devi_name, 486 DEVI(child)->devi_instance, level, vec); 487 goto broken; 488 } 489 new->intrspec_pri = level; 490 if (vec != 2) 491 new->intrspec_vec = vec; 492 else 493 /* 494 * irq 2 on the PC bus is tied to irq 9 495 * on ISA, EISA and MicroChannel 496 */ 497 new->intrspec_vec = 9; 498 new++; 499 } 500 501 return (DDI_SUCCESS); 502 } else { 503 /* the new style "interrupts" property... */ 504 505 /* 506 * The list consists of <vec> elements 507 */ 508 if ((n = (*in++)) < 1) 509 return (DDI_FAILURE); 510 511 pdptr->par_nintr = n; 512 size = n * sizeof (struct intrspec); 513 new = pdptr->par_intr = kmem_zalloc(size, KM_SLEEP); 514 515 /* XXX check for "interrupt-priorities" property... */ 516 if (ddi_getlongprop(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS, 517 "interrupt-priorities", (caddr_t)&got_prop, &got_len) 518 == DDI_PROP_SUCCESS) { 519 if (n != (got_len / sizeof (int))) { 520 cmn_err(CE_CONT, 521 "bad interrupt-priorities length" 522 " from %s%d: expected %d, got %d\n", 523 DEVI(child)->devi_name, 524 DEVI(child)->devi_instance, n, 525 (int)(got_len / sizeof (int))); 526 goto broken; 527 } 528 inpri = (int *)got_prop; 529 } 530 531 while (n--) { 532 int level; 533 int vec = *in++; 534 535 if (inpri == NULL) 536 level = 5; 537 else 538 level = *inpri++; 539 540 if (level < 1 || level > MAXIPL || 541 vec < VEC_MIN || vec > VEC_MAX) { 542 cmn_err(CE_CONT, bad_intr_fmt, 543 DEVI(child)->devi_name, 544 DEVI(child)->devi_instance, level, vec); 545 goto broken; 546 } 547 new->intrspec_pri = level; 548 if (vec != 2) 549 new->intrspec_vec = vec; 550 else 551 /* 552 * irq 2 on the PC bus is tied to irq 9 553 * on ISA, EISA and MicroChannel 554 */ 555 new->intrspec_vec = 9; 556 new++; 557 } 558 559 if (inpri != NULL) 560 kmem_free(got_prop, got_len); 561 return (DDI_SUCCESS); 562 } 563 564 broken: 565 kmem_free(pdptr->par_intr, size); 566 pdptr->par_intr = NULL; 567 pdptr->par_nintr = 0; 568 if (inpri != NULL) 569 kmem_free(got_prop, got_len); 570 571 return (DDI_FAILURE); 572 } 573 574 /* 575 * Create a ddi_parent_private_data structure from the ddi properties of 576 * the dev_info node. 577 * 578 * The "reg" and either an "intr" or "interrupts" properties are required 579 * if the driver wishes to create mappings or field interrupts on behalf 580 * of the device. 581 * 582 * The "reg" property is assumed to be a list of at least one triple 583 * 584 * <bustype, address, size>*1 585 * 586 * The "intr" property is assumed to be a list of at least one duple 587 * 588 * <SPARC ipl, vector#>*1 589 * 590 * The "interrupts" property is assumed to be a list of at least one 591 * n-tuples that describes the interrupt capabilities of the bus the device 592 * is connected to. For SBus, this looks like 593 * 594 * <SBus-level>*1 595 * 596 * (This property obsoletes the 'intr' property). 597 * 598 * The "ranges" property is optional. 599 */ 600 void 601 make_ddi_ppd(dev_info_t *child, struct ddi_parent_private_data **ppd) 602 { 603 struct ddi_parent_private_data *pdptr; 604 int n; 605 int *reg_prop, *rng_prop, *intr_prop, *irupts_prop; 606 uint_t reg_len, rng_len, intr_len, irupts_len; 607 608 *ppd = pdptr = kmem_zalloc(sizeof (*pdptr), KM_SLEEP); 609 610 /* 611 * Handle the 'reg' property. 612 */ 613 if ((get_prop_int_array(child, "reg", ®_prop, ®_len) == 614 DDI_PROP_SUCCESS) && (reg_len != 0)) { 615 pdptr->par_nreg = reg_len / (int)sizeof (struct regspec); 616 pdptr->par_reg = (struct regspec *)reg_prop; 617 } 618 619 /* 620 * See if I have a range (adding one where needed - this 621 * means to add one for sbus node in sun4c, when romvec > 0, 622 * if no range is already defined in the PROM node. 623 * (Currently no sun4c PROMS define range properties, 624 * but they should and may in the future.) For the SBus 625 * node, the range is defined by the SBus reg property. 626 */ 627 if (get_prop_int_array(child, "ranges", &rng_prop, &rng_len) 628 == DDI_PROP_SUCCESS) { 629 pdptr->par_nrng = rng_len / (int)(sizeof (struct rangespec)); 630 pdptr->par_rng = (struct rangespec *)rng_prop; 631 } 632 633 /* 634 * Handle the 'intr' and 'interrupts' properties 635 */ 636 637 /* 638 * For backwards compatibility 639 * we first look for the 'intr' property for the device. 640 */ 641 if (get_prop_int_array(child, "intr", &intr_prop, &intr_len) 642 != DDI_PROP_SUCCESS) { 643 intr_len = 0; 644 } 645 646 /* 647 * If we're to support bus adapters and future platforms cleanly, 648 * we need to support the generalized 'interrupts' property. 649 */ 650 if (get_prop_int_array(child, "interrupts", &irupts_prop, 651 &irupts_len) != DDI_PROP_SUCCESS) { 652 irupts_len = 0; 653 } else if (intr_len != 0) { 654 /* 655 * If both 'intr' and 'interrupts' are defined, 656 * then 'interrupts' wins and we toss the 'intr' away. 657 */ 658 ddi_prop_free((void *)intr_prop); 659 intr_len = 0; 660 } 661 662 if (intr_len != 0) { 663 664 /* 665 * Translate the 'intr' property into an array 666 * an array of struct intrspec's. There's not really 667 * very much to do here except copy what's out there. 668 */ 669 670 struct intrspec *new; 671 struct prop_ispec *l; 672 673 n = pdptr->par_nintr = intr_len / sizeof (struct prop_ispec); 674 l = (struct prop_ispec *)intr_prop; 675 pdptr->par_intr = 676 new = kmem_zalloc(n * sizeof (struct intrspec), KM_SLEEP); 677 while (n--) { 678 new->intrspec_pri = l->pri; 679 new->intrspec_vec = l->vec; 680 new++; 681 l++; 682 } 683 ddi_prop_free((void *)intr_prop); 684 685 } else if ((n = irupts_len) != 0) { 686 size_t size; 687 int *out; 688 689 /* 690 * Translate the 'interrupts' property into an array 691 * of intrspecs for the rest of the DDI framework to 692 * toy with. Only our ancestors really know how to 693 * do this, so ask 'em. We massage the 'interrupts' 694 * property so that it is pre-pended by a count of 695 * the number of integers in the argument. 696 */ 697 size = sizeof (int) + n; 698 out = kmem_alloc(size, KM_SLEEP); 699 *out = n / sizeof (int); 700 bcopy(irupts_prop, out + 1, (size_t)n); 701 ddi_prop_free((void *)irupts_prop); 702 if (impl_xlate_intrs(child, out, pdptr) != DDI_SUCCESS) { 703 cmn_err(CE_CONT, 704 "Unable to translate 'interrupts' for %s%d\n", 705 DEVI(child)->devi_binding_name, 706 DEVI(child)->devi_instance); 707 } 708 kmem_free(out, size); 709 } 710 } 711 712 /* 713 * Name a child 714 */ 715 static int 716 impl_sunbus_name_child(dev_info_t *child, char *name, int namelen) 717 { 718 /* 719 * Fill in parent-private data and this function returns to us 720 * an indication if it used "registers" to fill in the data. 721 */ 722 if (ddi_get_parent_data(child) == NULL) { 723 struct ddi_parent_private_data *pdptr; 724 make_ddi_ppd(child, &pdptr); 725 ddi_set_parent_data(child, pdptr); 726 } 727 728 name[0] = '\0'; 729 if (sparc_pd_getnreg(child) > 0) { 730 (void) snprintf(name, namelen, "%x,%x", 731 (uint_t)sparc_pd_getreg(child, 0)->regspec_bustype, 732 (uint_t)sparc_pd_getreg(child, 0)->regspec_addr); 733 } 734 735 return (DDI_SUCCESS); 736 } 737 738 /* 739 * Called from the bus_ctl op of sunbus (sbus, obio, etc) nexus drivers 740 * to implement the DDI_CTLOPS_INITCHILD operation. That is, it names 741 * the children of sun busses based on the reg spec. 742 * 743 * Handles the following properties (in make_ddi_ppd): 744 * Property value 745 * Name type 746 * reg register spec 747 * intr old-form interrupt spec 748 * interrupts new (bus-oriented) interrupt spec 749 * ranges range spec 750 */ 751 int 752 impl_ddi_sunbus_initchild(dev_info_t *child) 753 { 754 char name[MAXNAMELEN]; 755 void impl_ddi_sunbus_removechild(dev_info_t *); 756 757 /* 758 * Name the child, also makes parent private data 759 */ 760 (void) impl_sunbus_name_child(child, name, MAXNAMELEN); 761 ddi_set_name_addr(child, name); 762 763 /* 764 * Attempt to merge a .conf node; if successful, remove the 765 * .conf node. 766 */ 767 if ((ndi_dev_is_persistent_node(child) == 0) && 768 (ndi_merge_node(child, impl_sunbus_name_child) == DDI_SUCCESS)) { 769 /* 770 * Return failure to remove node 771 */ 772 impl_ddi_sunbus_removechild(child); 773 return (DDI_FAILURE); 774 } 775 return (DDI_SUCCESS); 776 } 777 778 void 779 impl_free_ddi_ppd(dev_info_t *dip) 780 { 781 struct ddi_parent_private_data *pdptr; 782 size_t n; 783 784 if ((pdptr = ddi_get_parent_data(dip)) == NULL) 785 return; 786 787 if ((n = (size_t)pdptr->par_nintr) != 0) 788 /* 789 * Note that kmem_free is used here (instead of 790 * ddi_prop_free) because the contents of the 791 * property were placed into a separate buffer and 792 * mucked with a bit before being stored in par_intr. 793 * The actual return value from the prop lookup 794 * was freed with ddi_prop_free previously. 795 */ 796 kmem_free(pdptr->par_intr, n * sizeof (struct intrspec)); 797 798 if ((n = (size_t)pdptr->par_nrng) != 0) 799 ddi_prop_free((void *)pdptr->par_rng); 800 801 if ((n = pdptr->par_nreg) != 0) 802 ddi_prop_free((void *)pdptr->par_reg); 803 804 kmem_free(pdptr, sizeof (*pdptr)); 805 ddi_set_parent_data(dip, NULL); 806 } 807 808 void 809 impl_ddi_sunbus_removechild(dev_info_t *dip) 810 { 811 impl_free_ddi_ppd(dip); 812 ddi_set_name_addr(dip, NULL); 813 /* 814 * Strip the node to properly convert it back to prototype form 815 */ 816 impl_rem_dev_props(dip); 817 } 818 819 /* 820 * DDI Interrupt 821 */ 822 823 /* 824 * turn this on to force isa, eisa, and mca device to ignore the new 825 * hardware nodes in the device tree (normally turned on only for 826 * drivers that need it by setting the property "ignore-hardware-nodes" 827 * in their driver.conf file). 828 * 829 * 7/31/96 -- Turned off globally. Leaving variable in for the moment 830 * as safety valve. 831 */ 832 int ignore_hardware_nodes = 0; 833 834 /* 835 * New DDI interrupt framework 836 */ 837 838 /* 839 * i_ddi_intr_ops: 840 * 841 * This is the interrupt operator function wrapper for the bus function 842 * bus_intr_op. 843 */ 844 int 845 i_ddi_intr_ops(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t op, 846 ddi_intr_handle_impl_t *hdlp, void * result) 847 { 848 dev_info_t *pdip = (dev_info_t *)DEVI(dip)->devi_parent; 849 int ret = DDI_FAILURE; 850 851 /* request parent to process this interrupt op */ 852 if (NEXUS_HAS_INTR_OP(pdip)) 853 ret = (*(DEVI(pdip)->devi_ops->devo_bus_ops->bus_intr_op))( 854 pdip, rdip, op, hdlp, result); 855 else 856 cmn_err(CE_WARN, "Failed to process interrupt " 857 "for %s%d due to down-rev nexus driver %s%d", 858 ddi_get_name(rdip), ddi_get_instance(rdip), 859 ddi_get_name(pdip), ddi_get_instance(pdip)); 860 return (ret); 861 } 862 863 /* 864 * i_ddi_add_softint - allocate and add a soft interrupt to the system 865 */ 866 int 867 i_ddi_add_softint(ddi_softint_hdl_impl_t *hdlp) 868 { 869 int ret; 870 871 /* add soft interrupt handler */ 872 ret = add_avsoftintr((void *)hdlp, hdlp->ih_pri, hdlp->ih_cb_func, 873 DEVI(hdlp->ih_dip)->devi_name, hdlp->ih_cb_arg1, hdlp->ih_cb_arg2); 874 return (ret ? DDI_SUCCESS : DDI_FAILURE); 875 } 876 877 878 void 879 i_ddi_remove_softint(ddi_softint_hdl_impl_t *hdlp) 880 { 881 (void) rem_avsoftintr((void *)hdlp, hdlp->ih_pri, hdlp->ih_cb_func); 882 } 883 884 885 extern void (*setsoftint)(int, struct av_softinfo *); 886 extern boolean_t av_check_softint_pending(struct av_softinfo *, boolean_t); 887 888 int 889 i_ddi_trigger_softint(ddi_softint_hdl_impl_t *hdlp, void *arg2) 890 { 891 if (av_check_softint_pending(hdlp->ih_pending, B_FALSE)) 892 return (DDI_EPENDING); 893 894 update_avsoftintr_args((void *)hdlp, hdlp->ih_pri, arg2); 895 896 (*setsoftint)(hdlp->ih_pri, hdlp->ih_pending); 897 return (DDI_SUCCESS); 898 } 899 900 /* 901 * i_ddi_set_softint_pri: 902 * 903 * The way this works is that it first tries to add a softint vector 904 * at the new priority in hdlp. If that succeeds; then it removes the 905 * existing softint vector at the old priority. 906 */ 907 int 908 i_ddi_set_softint_pri(ddi_softint_hdl_impl_t *hdlp, uint_t old_pri) 909 { 910 int ret; 911 912 /* 913 * If a softint is pending at the old priority then fail the request. 914 */ 915 if (av_check_softint_pending(hdlp->ih_pending, B_TRUE)) 916 return (DDI_FAILURE); 917 918 ret = av_softint_movepri((void *)hdlp, old_pri); 919 return (ret ? DDI_SUCCESS : DDI_FAILURE); 920 } 921 922 void 923 i_ddi_alloc_intr_phdl(ddi_intr_handle_impl_t *hdlp) 924 { 925 hdlp->ih_private = (void *)kmem_zalloc(sizeof (ihdl_plat_t), KM_SLEEP); 926 } 927 928 void 929 i_ddi_free_intr_phdl(ddi_intr_handle_impl_t *hdlp) 930 { 931 kmem_free(hdlp->ih_private, sizeof (ihdl_plat_t)); 932 hdlp->ih_private = NULL; 933 } 934 935 int 936 i_ddi_get_intx_nintrs(dev_info_t *dip) 937 { 938 struct ddi_parent_private_data *pdp; 939 940 if ((pdp = ddi_get_parent_data(dip)) == NULL) 941 return (0); 942 943 return (pdp->par_nintr); 944 } 945 946 /* 947 * DDI Memory/DMA 948 */ 949 950 /* 951 * Support for allocating DMAable memory to implement 952 * ddi_dma_mem_alloc(9F) interface. 953 */ 954 955 #define KA_ALIGN_SHIFT 7 956 #define KA_ALIGN (1 << KA_ALIGN_SHIFT) 957 #define KA_NCACHE (PAGESHIFT + 1 - KA_ALIGN_SHIFT) 958 959 /* 960 * Dummy DMA attribute template for kmem_io[].kmem_io_attr. We only 961 * care about addr_lo, addr_hi, and align. addr_hi will be dynamically set. 962 */ 963 964 static ddi_dma_attr_t kmem_io_attr = { 965 DMA_ATTR_V0, 966 0x0000000000000000ULL, /* dma_attr_addr_lo */ 967 0x0000000000000000ULL, /* dma_attr_addr_hi */ 968 0x00ffffff, 969 0x1000, /* dma_attr_align */ 970 1, 1, 0xffffffffULL, 0xffffffffULL, 0x1, 1, 0 971 }; 972 973 /* kmem io memory ranges and indices */ 974 enum { 975 IO_4P, IO_64G, IO_4G, IO_2G, IO_1G, IO_512M, 976 IO_256M, IO_128M, IO_64M, IO_32M, IO_16M, MAX_MEM_RANGES 977 }; 978 979 static struct { 980 vmem_t *kmem_io_arena; 981 kmem_cache_t *kmem_io_cache[KA_NCACHE]; 982 ddi_dma_attr_t kmem_io_attr; 983 } kmem_io[MAX_MEM_RANGES]; 984 985 static int kmem_io_idx; /* index of first populated kmem_io[] */ 986 987 static page_t * 988 page_create_io_wrapper(void *addr, size_t len, int vmflag, void *arg) 989 { 990 extern page_t *page_create_io(vnode_t *, u_offset_t, uint_t, 991 uint_t, struct as *, caddr_t, ddi_dma_attr_t *); 992 993 return (page_create_io(&kvp, (u_offset_t)(uintptr_t)addr, len, 994 PG_EXCL | ((vmflag & VM_NOSLEEP) ? 0 : PG_WAIT), &kas, addr, arg)); 995 } 996 997 #ifdef __xpv 998 static void 999 segkmem_free_io(vmem_t *vmp, void *ptr, size_t size) 1000 { 1001 extern void page_destroy_io(page_t *); 1002 segkmem_xfree(vmp, ptr, size, &kvp, page_destroy_io); 1003 } 1004 #endif 1005 1006 static void * 1007 segkmem_alloc_io_4P(vmem_t *vmp, size_t size, int vmflag) 1008 { 1009 return (segkmem_xalloc(vmp, NULL, size, vmflag, 0, 1010 page_create_io_wrapper, &kmem_io[IO_4P].kmem_io_attr)); 1011 } 1012 1013 static void * 1014 segkmem_alloc_io_64G(vmem_t *vmp, size_t size, int vmflag) 1015 { 1016 return (segkmem_xalloc(vmp, NULL, size, vmflag, 0, 1017 page_create_io_wrapper, &kmem_io[IO_64G].kmem_io_attr)); 1018 } 1019 1020 static void * 1021 segkmem_alloc_io_4G(vmem_t *vmp, size_t size, int vmflag) 1022 { 1023 return (segkmem_xalloc(vmp, NULL, size, vmflag, 0, 1024 page_create_io_wrapper, &kmem_io[IO_4G].kmem_io_attr)); 1025 } 1026 1027 static void * 1028 segkmem_alloc_io_2G(vmem_t *vmp, size_t size, int vmflag) 1029 { 1030 return (segkmem_xalloc(vmp, NULL, size, vmflag, 0, 1031 page_create_io_wrapper, &kmem_io[IO_2G].kmem_io_attr)); 1032 } 1033 1034 static void * 1035 segkmem_alloc_io_1G(vmem_t *vmp, size_t size, int vmflag) 1036 { 1037 return (segkmem_xalloc(vmp, NULL, size, vmflag, 0, 1038 page_create_io_wrapper, &kmem_io[IO_1G].kmem_io_attr)); 1039 } 1040 1041 static void * 1042 segkmem_alloc_io_512M(vmem_t *vmp, size_t size, int vmflag) 1043 { 1044 return (segkmem_xalloc(vmp, NULL, size, vmflag, 0, 1045 page_create_io_wrapper, &kmem_io[IO_512M].kmem_io_attr)); 1046 } 1047 1048 static void * 1049 segkmem_alloc_io_256M(vmem_t *vmp, size_t size, int vmflag) 1050 { 1051 return (segkmem_xalloc(vmp, NULL, size, vmflag, 0, 1052 page_create_io_wrapper, &kmem_io[IO_256M].kmem_io_attr)); 1053 } 1054 1055 static void * 1056 segkmem_alloc_io_128M(vmem_t *vmp, size_t size, int vmflag) 1057 { 1058 return (segkmem_xalloc(vmp, NULL, size, vmflag, 0, 1059 page_create_io_wrapper, &kmem_io[IO_128M].kmem_io_attr)); 1060 } 1061 1062 static void * 1063 segkmem_alloc_io_64M(vmem_t *vmp, size_t size, int vmflag) 1064 { 1065 return (segkmem_xalloc(vmp, NULL, size, vmflag, 0, 1066 page_create_io_wrapper, &kmem_io[IO_64M].kmem_io_attr)); 1067 } 1068 1069 static void * 1070 segkmem_alloc_io_32M(vmem_t *vmp, size_t size, int vmflag) 1071 { 1072 return (segkmem_xalloc(vmp, NULL, size, vmflag, 0, 1073 page_create_io_wrapper, &kmem_io[IO_32M].kmem_io_attr)); 1074 } 1075 1076 static void * 1077 segkmem_alloc_io_16M(vmem_t *vmp, size_t size, int vmflag) 1078 { 1079 return (segkmem_xalloc(vmp, NULL, size, vmflag, 0, 1080 page_create_io_wrapper, &kmem_io[IO_16M].kmem_io_attr)); 1081 } 1082 1083 struct { 1084 uint64_t io_limit; 1085 char *io_name; 1086 void *(*io_alloc)(vmem_t *, size_t, int); 1087 int io_initial; /* kmem_io_init during startup */ 1088 } io_arena_params[MAX_MEM_RANGES] = { 1089 {0x000fffffffffffffULL, "kmem_io_4P", segkmem_alloc_io_4P, 1}, 1090 {0x0000000fffffffffULL, "kmem_io_64G", segkmem_alloc_io_64G, 0}, 1091 {0x00000000ffffffffULL, "kmem_io_4G", segkmem_alloc_io_4G, 1}, 1092 {0x000000007fffffffULL, "kmem_io_2G", segkmem_alloc_io_2G, 1}, 1093 {0x000000003fffffffULL, "kmem_io_1G", segkmem_alloc_io_1G, 0}, 1094 {0x000000001fffffffULL, "kmem_io_512M", segkmem_alloc_io_512M, 0}, 1095 {0x000000000fffffffULL, "kmem_io_256M", segkmem_alloc_io_256M, 0}, 1096 {0x0000000007ffffffULL, "kmem_io_128M", segkmem_alloc_io_128M, 0}, 1097 {0x0000000003ffffffULL, "kmem_io_64M", segkmem_alloc_io_64M, 0}, 1098 {0x0000000001ffffffULL, "kmem_io_32M", segkmem_alloc_io_32M, 0}, 1099 {0x0000000000ffffffULL, "kmem_io_16M", segkmem_alloc_io_16M, 1} 1100 }; 1101 1102 void 1103 kmem_io_init(int a) 1104 { 1105 int c; 1106 char name[40]; 1107 1108 kmem_io[a].kmem_io_arena = vmem_create(io_arena_params[a].io_name, 1109 NULL, 0, PAGESIZE, io_arena_params[a].io_alloc, 1110 #ifdef __xpv 1111 segkmem_free_io, 1112 #else 1113 segkmem_free, 1114 #endif 1115 heap_arena, 0, VM_SLEEP); 1116 1117 for (c = 0; c < KA_NCACHE; c++) { 1118 size_t size = KA_ALIGN << c; 1119 (void) sprintf(name, "%s_%lu", 1120 io_arena_params[a].io_name, size); 1121 kmem_io[a].kmem_io_cache[c] = kmem_cache_create(name, 1122 size, size, NULL, NULL, NULL, NULL, 1123 kmem_io[a].kmem_io_arena, 0); 1124 } 1125 } 1126 1127 /* 1128 * Return the index of the highest memory range for addr. 1129 */ 1130 static int 1131 kmem_io_index(uint64_t addr) 1132 { 1133 int n; 1134 1135 for (n = kmem_io_idx; n < MAX_MEM_RANGES; n++) { 1136 if (kmem_io[n].kmem_io_attr.dma_attr_addr_hi <= addr) { 1137 if (kmem_io[n].kmem_io_arena == NULL) 1138 kmem_io_init(n); 1139 return (n); 1140 } 1141 } 1142 panic("kmem_io_index: invalid addr - must be at least 16m"); 1143 1144 /*NOTREACHED*/ 1145 } 1146 1147 /* 1148 * Return the index of the next kmem_io populated memory range 1149 * after curindex. 1150 */ 1151 static int 1152 kmem_io_index_next(int curindex) 1153 { 1154 int n; 1155 1156 for (n = curindex + 1; n < MAX_MEM_RANGES; n++) { 1157 if (kmem_io[n].kmem_io_arena) 1158 return (n); 1159 } 1160 return (-1); 1161 } 1162 1163 /* 1164 * allow kmem to be mapped in with different PTE cache attribute settings. 1165 * Used by i_ddi_mem_alloc() 1166 */ 1167 int 1168 kmem_override_cache_attrs(caddr_t kva, size_t size, uint_t order) 1169 { 1170 uint_t hat_flags; 1171 caddr_t kva_end; 1172 uint_t hat_attr; 1173 pfn_t pfn; 1174 1175 if (hat_getattr(kas.a_hat, kva, &hat_attr) == -1) { 1176 return (-1); 1177 } 1178 1179 hat_attr &= ~HAT_ORDER_MASK; 1180 hat_attr |= order | HAT_NOSYNC; 1181 hat_flags = HAT_LOAD_LOCK; 1182 1183 kva_end = (caddr_t)(((uintptr_t)kva + size + PAGEOFFSET) & 1184 (uintptr_t)PAGEMASK); 1185 kva = (caddr_t)((uintptr_t)kva & (uintptr_t)PAGEMASK); 1186 1187 while (kva < kva_end) { 1188 pfn = hat_getpfnum(kas.a_hat, kva); 1189 hat_unload(kas.a_hat, kva, PAGESIZE, HAT_UNLOAD_UNLOCK); 1190 hat_devload(kas.a_hat, kva, PAGESIZE, pfn, hat_attr, hat_flags); 1191 kva += MMU_PAGESIZE; 1192 } 1193 1194 return (0); 1195 } 1196 1197 static int 1198 ctgcompare(const void *a1, const void *a2) 1199 { 1200 /* we just want to compare virtual addresses */ 1201 a1 = ((struct ctgas *)a1)->ctg_addr; 1202 a2 = ((struct ctgas *)a2)->ctg_addr; 1203 return (a1 == a2 ? 0 : (a1 < a2 ? -1 : 1)); 1204 } 1205 1206 void 1207 ka_init(void) 1208 { 1209 int a; 1210 paddr_t maxphysaddr; 1211 #if !defined(__xpv) 1212 extern pfn_t physmax; 1213 1214 maxphysaddr = mmu_ptob((paddr_t)physmax) + MMU_PAGEOFFSET; 1215 #else 1216 maxphysaddr = mmu_ptob((paddr_t)HYPERVISOR_memory_op( 1217 XENMEM_maximum_ram_page, NULL)) + MMU_PAGEOFFSET; 1218 #endif 1219 1220 ASSERT(maxphysaddr <= io_arena_params[0].io_limit); 1221 1222 for (a = 0; a < MAX_MEM_RANGES; a++) { 1223 if (maxphysaddr >= io_arena_params[a + 1].io_limit) { 1224 if (maxphysaddr > io_arena_params[a + 1].io_limit) 1225 io_arena_params[a].io_limit = maxphysaddr; 1226 else 1227 a++; 1228 break; 1229 } 1230 } 1231 kmem_io_idx = a; 1232 1233 for (; a < MAX_MEM_RANGES; a++) { 1234 kmem_io[a].kmem_io_attr = kmem_io_attr; 1235 kmem_io[a].kmem_io_attr.dma_attr_addr_hi = 1236 io_arena_params[a].io_limit; 1237 /* 1238 * initialize kmem_io[] arena/cache corresponding to 1239 * maxphysaddr and to the "common" io memory ranges that 1240 * have io_initial set to a non-zero value. 1241 */ 1242 if (io_arena_params[a].io_initial || a == kmem_io_idx) 1243 kmem_io_init(a); 1244 } 1245 1246 /* initialize ctgtree */ 1247 avl_create(&ctgtree, ctgcompare, sizeof (struct ctgas), 1248 offsetof(struct ctgas, ctg_link)); 1249 } 1250 1251 /* 1252 * put contig address/size 1253 */ 1254 static void * 1255 putctgas(void *addr, size_t size) 1256 { 1257 struct ctgas *ctgp; 1258 if ((ctgp = kmem_zalloc(sizeof (*ctgp), KM_NOSLEEP)) != NULL) { 1259 ctgp->ctg_addr = addr; 1260 ctgp->ctg_size = size; 1261 CTGLOCK(); 1262 avl_add(&ctgtree, ctgp); 1263 CTGUNLOCK(); 1264 } 1265 return (ctgp); 1266 } 1267 1268 /* 1269 * get contig size by addr 1270 */ 1271 static size_t 1272 getctgsz(void *addr) 1273 { 1274 struct ctgas *ctgp; 1275 struct ctgas find; 1276 size_t sz = 0; 1277 1278 find.ctg_addr = addr; 1279 CTGLOCK(); 1280 if ((ctgp = avl_find(&ctgtree, &find, NULL)) != NULL) { 1281 avl_remove(&ctgtree, ctgp); 1282 } 1283 CTGUNLOCK(); 1284 1285 if (ctgp != NULL) { 1286 sz = ctgp->ctg_size; 1287 kmem_free(ctgp, sizeof (*ctgp)); 1288 } 1289 1290 return (sz); 1291 } 1292 1293 /* 1294 * contig_alloc: 1295 * 1296 * allocates contiguous memory to satisfy the 'size' and dma attributes 1297 * specified in 'attr'. 1298 * 1299 * Not all of memory need to be physically contiguous if the 1300 * scatter-gather list length is greater than 1. 1301 */ 1302 1303 /*ARGSUSED*/ 1304 void * 1305 contig_alloc(size_t size, ddi_dma_attr_t *attr, uintptr_t align, int cansleep) 1306 { 1307 pgcnt_t pgcnt = btopr(size); 1308 size_t asize = pgcnt * PAGESIZE; 1309 page_t *ppl; 1310 int pflag; 1311 void *addr; 1312 1313 extern page_t *page_create_io(vnode_t *, u_offset_t, uint_t, 1314 uint_t, struct as *, caddr_t, ddi_dma_attr_t *); 1315 1316 /* segkmem_xalloc */ 1317 1318 if (align <= PAGESIZE) 1319 addr = vmem_alloc(heap_arena, asize, 1320 (cansleep) ? VM_SLEEP : VM_NOSLEEP); 1321 else 1322 addr = vmem_xalloc(heap_arena, asize, align, 0, 0, NULL, NULL, 1323 (cansleep) ? VM_SLEEP : VM_NOSLEEP); 1324 if (addr) { 1325 ASSERT(!((uintptr_t)addr & (align - 1))); 1326 1327 if (page_resv(pgcnt, (cansleep) ? KM_SLEEP : KM_NOSLEEP) == 0) { 1328 vmem_free(heap_arena, addr, asize); 1329 return (NULL); 1330 } 1331 pflag = PG_EXCL; 1332 1333 if (cansleep) 1334 pflag |= PG_WAIT; 1335 1336 /* 4k req gets from freelists rather than pfn search */ 1337 if (pgcnt > 1 || align > PAGESIZE) 1338 pflag |= PG_PHYSCONTIG; 1339 1340 ppl = page_create_io(&kvp, (u_offset_t)(uintptr_t)addr, 1341 asize, pflag, &kas, (caddr_t)addr, attr); 1342 1343 if (!ppl) { 1344 vmem_free(heap_arena, addr, asize); 1345 page_unresv(pgcnt); 1346 return (NULL); 1347 } 1348 1349 while (ppl != NULL) { 1350 page_t *pp = ppl; 1351 page_sub(&ppl, pp); 1352 ASSERT(page_iolock_assert(pp)); 1353 page_io_unlock(pp); 1354 page_downgrade(pp); 1355 hat_memload(kas.a_hat, (caddr_t)(uintptr_t)pp->p_offset, 1356 pp, (PROT_ALL & ~PROT_USER) | 1357 HAT_NOSYNC, HAT_LOAD_LOCK); 1358 } 1359 } 1360 return (addr); 1361 } 1362 1363 void 1364 contig_free(void *addr, size_t size) 1365 { 1366 pgcnt_t pgcnt = btopr(size); 1367 size_t asize = pgcnt * PAGESIZE; 1368 caddr_t a, ea; 1369 page_t *pp; 1370 1371 hat_unload(kas.a_hat, addr, asize, HAT_UNLOAD_UNLOCK); 1372 1373 for (a = addr, ea = a + asize; a < ea; a += PAGESIZE) { 1374 pp = page_find(&kvp, (u_offset_t)(uintptr_t)a); 1375 if (!pp) 1376 panic("contig_free: contig pp not found"); 1377 1378 if (!page_tryupgrade(pp)) { 1379 page_unlock(pp); 1380 pp = page_lookup(&kvp, 1381 (u_offset_t)(uintptr_t)a, SE_EXCL); 1382 if (pp == NULL) 1383 panic("contig_free: page freed"); 1384 } 1385 page_destroy(pp, 0); 1386 } 1387 1388 page_unresv(pgcnt); 1389 vmem_free(heap_arena, addr, asize); 1390 } 1391 1392 /* 1393 * Allocate from the system, aligned on a specific boundary. 1394 * The alignment, if non-zero, must be a power of 2. 1395 */ 1396 static void * 1397 kalloca(size_t size, size_t align, int cansleep, int physcontig, 1398 ddi_dma_attr_t *attr) 1399 { 1400 size_t *addr, *raddr, rsize; 1401 size_t hdrsize = 4 * sizeof (size_t); /* must be power of 2 */ 1402 int a, i, c; 1403 vmem_t *vmp = NULL; 1404 kmem_cache_t *cp = NULL; 1405 1406 if (attr->dma_attr_addr_lo > mmu_ptob((uint64_t)ddiphysmin)) 1407 return (NULL); 1408 1409 align = MAX(align, hdrsize); 1410 ASSERT((align & (align - 1)) == 0); 1411 1412 /* 1413 * All of our allocators guarantee 16-byte alignment, so we don't 1414 * need to reserve additional space for the header. 1415 * To simplify picking the correct kmem_io_cache, we round up to 1416 * a multiple of KA_ALIGN. 1417 */ 1418 rsize = P2ROUNDUP_TYPED(size + align, KA_ALIGN, size_t); 1419 1420 if (physcontig && rsize > PAGESIZE) { 1421 if ((addr = contig_alloc(size, attr, align, cansleep)) != 1422 NULL) { 1423 if (!putctgas(addr, size)) 1424 contig_free(addr, size); 1425 else 1426 return (addr); 1427 } 1428 return (NULL); 1429 } 1430 1431 a = kmem_io_index(attr->dma_attr_addr_hi); 1432 1433 if (rsize > PAGESIZE) { 1434 vmp = kmem_io[a].kmem_io_arena; 1435 raddr = vmem_alloc(vmp, rsize, 1436 (cansleep) ? VM_SLEEP : VM_NOSLEEP); 1437 } else { 1438 c = highbit((rsize >> KA_ALIGN_SHIFT) - 1); 1439 cp = kmem_io[a].kmem_io_cache[c]; 1440 raddr = kmem_cache_alloc(cp, (cansleep) ? KM_SLEEP : 1441 KM_NOSLEEP); 1442 } 1443 1444 if (raddr == NULL) { 1445 int na; 1446 1447 ASSERT(cansleep == 0); 1448 if (rsize > PAGESIZE) 1449 return (NULL); 1450 /* 1451 * System does not have memory in the requested range. 1452 * Try smaller kmem io ranges and larger cache sizes 1453 * to see if there might be memory available in 1454 * these other caches. 1455 */ 1456 1457 for (na = kmem_io_index_next(a); na >= 0; 1458 na = kmem_io_index_next(na)) { 1459 ASSERT(kmem_io[na].kmem_io_arena); 1460 cp = kmem_io[na].kmem_io_cache[c]; 1461 raddr = kmem_cache_alloc(cp, KM_NOSLEEP); 1462 if (raddr) 1463 goto kallocdone; 1464 } 1465 /* now try the larger kmem io cache sizes */ 1466 for (na = a; na >= 0; na = kmem_io_index_next(na)) { 1467 for (i = c + 1; i < KA_NCACHE; i++) { 1468 cp = kmem_io[na].kmem_io_cache[i]; 1469 raddr = kmem_cache_alloc(cp, KM_NOSLEEP); 1470 if (raddr) 1471 goto kallocdone; 1472 } 1473 } 1474 return (NULL); 1475 } 1476 1477 kallocdone: 1478 ASSERT(!P2BOUNDARY((uintptr_t)raddr, rsize, PAGESIZE) || 1479 rsize > PAGESIZE); 1480 1481 addr = (size_t *)P2ROUNDUP((uintptr_t)raddr + hdrsize, align); 1482 ASSERT((uintptr_t)addr + size - (uintptr_t)raddr <= rsize); 1483 1484 addr[-4] = (size_t)cp; 1485 addr[-3] = (size_t)vmp; 1486 addr[-2] = (size_t)raddr; 1487 addr[-1] = rsize; 1488 1489 return (addr); 1490 } 1491 1492 static void 1493 kfreea(void *addr) 1494 { 1495 size_t size; 1496 1497 if (!((uintptr_t)addr & PAGEOFFSET) && (size = getctgsz(addr))) { 1498 contig_free(addr, size); 1499 } else { 1500 size_t *saddr = addr; 1501 if (saddr[-4] == 0) 1502 vmem_free((vmem_t *)saddr[-3], (void *)saddr[-2], 1503 saddr[-1]); 1504 else 1505 kmem_cache_free((kmem_cache_t *)saddr[-4], 1506 (void *)saddr[-2]); 1507 } 1508 } 1509 1510 /*ARGSUSED*/ 1511 void 1512 i_ddi_devacc_to_hatacc(const ddi_device_acc_attr_t *devaccp, uint_t *hataccp) 1513 { 1514 } 1515 1516 /* 1517 * Check if the specified cache attribute is supported on the platform. 1518 * This function must be called before i_ddi_cacheattr_to_hatacc(). 1519 */ 1520 boolean_t 1521 i_ddi_check_cache_attr(uint_t flags) 1522 { 1523 /* 1524 * The cache attributes are mutually exclusive. Any combination of 1525 * the attributes leads to a failure. 1526 */ 1527 uint_t cache_attr = IOMEM_CACHE_ATTR(flags); 1528 if ((cache_attr != 0) && !ISP2(cache_attr)) 1529 return (B_FALSE); 1530 1531 /* All cache attributes are supported on X86/X64 */ 1532 if (cache_attr & (IOMEM_DATA_UNCACHED | IOMEM_DATA_CACHED | 1533 IOMEM_DATA_UC_WR_COMBINE)) 1534 return (B_TRUE); 1535 1536 /* undefined attributes */ 1537 return (B_FALSE); 1538 } 1539 1540 /* set HAT cache attributes from the cache attributes */ 1541 void 1542 i_ddi_cacheattr_to_hatacc(uint_t flags, uint_t *hataccp) 1543 { 1544 uint_t cache_attr = IOMEM_CACHE_ATTR(flags); 1545 static char *fname = "i_ddi_cacheattr_to_hatacc"; 1546 1547 /* 1548 * If write-combining is not supported, then it falls back 1549 * to uncacheable. 1550 */ 1551 if (cache_attr == IOMEM_DATA_UC_WR_COMBINE && 1552 !is_x86_feature(x86_featureset, X86FSET_PAT)) 1553 cache_attr = IOMEM_DATA_UNCACHED; 1554 1555 /* 1556 * set HAT attrs according to the cache attrs. 1557 */ 1558 switch (cache_attr) { 1559 case IOMEM_DATA_UNCACHED: 1560 *hataccp &= ~HAT_ORDER_MASK; 1561 *hataccp |= (HAT_STRICTORDER | HAT_PLAT_NOCACHE); 1562 break; 1563 case IOMEM_DATA_UC_WR_COMBINE: 1564 *hataccp &= ~HAT_ORDER_MASK; 1565 *hataccp |= (HAT_MERGING_OK | HAT_PLAT_NOCACHE); 1566 break; 1567 case IOMEM_DATA_CACHED: 1568 *hataccp &= ~HAT_ORDER_MASK; 1569 *hataccp |= HAT_UNORDERED_OK; 1570 break; 1571 /* 1572 * This case must not occur because the cache attribute is scrutinized 1573 * before this function is called. 1574 */ 1575 default: 1576 /* 1577 * set cacheable to hat attrs. 1578 */ 1579 *hataccp &= ~HAT_ORDER_MASK; 1580 *hataccp |= HAT_UNORDERED_OK; 1581 cmn_err(CE_WARN, "%s: cache_attr=0x%x is ignored.", 1582 fname, cache_attr); 1583 } 1584 } 1585 1586 /* 1587 * This should actually be called i_ddi_dma_mem_alloc. There should 1588 * also be an i_ddi_pio_mem_alloc. i_ddi_dma_mem_alloc should call 1589 * through the device tree with the DDI_CTLOPS_DMA_ALIGN ctl ops to 1590 * get alignment requirements for DMA memory. i_ddi_pio_mem_alloc 1591 * should use DDI_CTLOPS_PIO_ALIGN. Since we only have i_ddi_mem_alloc 1592 * so far which is used for both, DMA and PIO, we have to use the DMA 1593 * ctl ops to make everybody happy. 1594 */ 1595 /*ARGSUSED*/ 1596 int 1597 i_ddi_mem_alloc(dev_info_t *dip, ddi_dma_attr_t *attr, 1598 size_t length, int cansleep, int flags, 1599 const ddi_device_acc_attr_t *accattrp, caddr_t *kaddrp, 1600 size_t *real_length, ddi_acc_hdl_t *ap) 1601 { 1602 caddr_t a; 1603 int iomin; 1604 ddi_acc_impl_t *iap; 1605 int physcontig = 0; 1606 pgcnt_t npages; 1607 pgcnt_t minctg; 1608 uint_t order; 1609 int e; 1610 1611 /* 1612 * Check legality of arguments 1613 */ 1614 if (length == 0 || kaddrp == NULL || attr == NULL) { 1615 return (DDI_FAILURE); 1616 } 1617 1618 if (attr->dma_attr_minxfer == 0 || attr->dma_attr_align == 0 || 1619 !ISP2(attr->dma_attr_align) || !ISP2(attr->dma_attr_minxfer)) { 1620 return (DDI_FAILURE); 1621 } 1622 1623 /* 1624 * figure out most restrictive alignment requirement 1625 */ 1626 iomin = attr->dma_attr_minxfer; 1627 iomin = maxbit(iomin, attr->dma_attr_align); 1628 if (iomin == 0) 1629 return (DDI_FAILURE); 1630 1631 ASSERT((iomin & (iomin - 1)) == 0); 1632 1633 /* 1634 * if we allocate memory with IOMEM_DATA_UNCACHED or 1635 * IOMEM_DATA_UC_WR_COMBINE, make sure we allocate a page aligned 1636 * memory that ends on a page boundry. 1637 * Don't want to have to different cache mappings to the same 1638 * physical page. 1639 */ 1640 if (OVERRIDE_CACHE_ATTR(flags)) { 1641 iomin = (iomin + MMU_PAGEOFFSET) & MMU_PAGEMASK; 1642 length = (length + MMU_PAGEOFFSET) & (size_t)MMU_PAGEMASK; 1643 } 1644 1645 /* 1646 * Determine if we need to satisfy the request for physically 1647 * contiguous memory or alignments larger than pagesize. 1648 */ 1649 npages = btopr(length + attr->dma_attr_align); 1650 minctg = howmany(npages, attr->dma_attr_sgllen); 1651 1652 if (minctg > 1) { 1653 uint64_t pfnseg = attr->dma_attr_seg >> PAGESHIFT; 1654 /* 1655 * verify that the minimum contig requirement for the 1656 * actual length does not cross segment boundary. 1657 */ 1658 length = P2ROUNDUP_TYPED(length, attr->dma_attr_minxfer, 1659 size_t); 1660 npages = btopr(length); 1661 minctg = howmany(npages, attr->dma_attr_sgllen); 1662 if (minctg > pfnseg + 1) 1663 return (DDI_FAILURE); 1664 physcontig = 1; 1665 } else { 1666 length = P2ROUNDUP_TYPED(length, iomin, size_t); 1667 } 1668 1669 /* 1670 * Allocate the requested amount from the system. 1671 */ 1672 a = kalloca(length, iomin, cansleep, physcontig, attr); 1673 1674 if ((*kaddrp = a) == NULL) 1675 return (DDI_FAILURE); 1676 1677 /* 1678 * if we to modify the cache attributes, go back and muck with the 1679 * mappings. 1680 */ 1681 if (OVERRIDE_CACHE_ATTR(flags)) { 1682 order = 0; 1683 i_ddi_cacheattr_to_hatacc(flags, &order); 1684 e = kmem_override_cache_attrs(a, length, order); 1685 if (e != 0) { 1686 kfreea(a); 1687 return (DDI_FAILURE); 1688 } 1689 } 1690 1691 if (real_length) { 1692 *real_length = length; 1693 } 1694 if (ap) { 1695 /* 1696 * initialize access handle 1697 */ 1698 iap = (ddi_acc_impl_t *)ap->ah_platform_private; 1699 iap->ahi_acc_attr |= DDI_ACCATTR_CPU_VADDR; 1700 impl_acc_hdl_init(ap); 1701 } 1702 1703 return (DDI_SUCCESS); 1704 } 1705 1706 /* ARGSUSED */ 1707 void 1708 i_ddi_mem_free(caddr_t kaddr, ddi_acc_hdl_t *ap) 1709 { 1710 if (ap != NULL) { 1711 /* 1712 * if we modified the cache attributes on alloc, go back and 1713 * fix them since this memory could be returned to the 1714 * general pool. 1715 */ 1716 if (OVERRIDE_CACHE_ATTR(ap->ah_xfermodes)) { 1717 uint_t order = 0; 1718 int e; 1719 i_ddi_cacheattr_to_hatacc(IOMEM_DATA_CACHED, &order); 1720 e = kmem_override_cache_attrs(kaddr, ap->ah_len, order); 1721 if (e != 0) { 1722 cmn_err(CE_WARN, "i_ddi_mem_free() failed to " 1723 "override cache attrs, memory leaked\n"); 1724 return; 1725 } 1726 } 1727 } 1728 kfreea(kaddr); 1729 } 1730 1731 /* 1732 * Access Barriers 1733 * 1734 */ 1735 /*ARGSUSED*/ 1736 int 1737 i_ddi_ontrap(ddi_acc_handle_t hp) 1738 { 1739 return (DDI_FAILURE); 1740 } 1741 1742 /*ARGSUSED*/ 1743 void 1744 i_ddi_notrap(ddi_acc_handle_t hp) 1745 { 1746 } 1747 1748 1749 /* 1750 * Misc Functions 1751 */ 1752 1753 /* 1754 * Implementation instance override functions 1755 * 1756 * No override on i86pc 1757 */ 1758 /*ARGSUSED*/ 1759 uint_t 1760 impl_assign_instance(dev_info_t *dip) 1761 { 1762 return ((uint_t)-1); 1763 } 1764 1765 /*ARGSUSED*/ 1766 int 1767 impl_keep_instance(dev_info_t *dip) 1768 { 1769 1770 #if defined(__xpv) 1771 /* 1772 * Do not persist instance numbers assigned to devices in dom0 1773 */ 1774 dev_info_t *pdip; 1775 if (DOMAIN_IS_INITDOMAIN(xen_info)) { 1776 if (((pdip = ddi_get_parent(dip)) != NULL) && 1777 (strcmp(ddi_get_name(pdip), "xpvd") == 0)) 1778 return (DDI_SUCCESS); 1779 } 1780 #endif 1781 return (DDI_FAILURE); 1782 } 1783 1784 /*ARGSUSED*/ 1785 int 1786 impl_free_instance(dev_info_t *dip) 1787 { 1788 return (DDI_FAILURE); 1789 } 1790 1791 /*ARGSUSED*/ 1792 int 1793 impl_check_cpu(dev_info_t *devi) 1794 { 1795 return (DDI_SUCCESS); 1796 } 1797 1798 /* 1799 * Referenced in common/cpr_driver.c: Power off machine. 1800 * Don't know how to power off i86pc. 1801 */ 1802 void 1803 arch_power_down() 1804 {} 1805 1806 /* 1807 * Copy name to property_name, since name 1808 * is in the low address range below kernelbase. 1809 */ 1810 static void 1811 copy_boot_str(const char *boot_str, char *kern_str, int len) 1812 { 1813 int i = 0; 1814 1815 while (i < len - 1 && boot_str[i] != '\0') { 1816 kern_str[i] = boot_str[i]; 1817 i++; 1818 } 1819 1820 kern_str[i] = 0; /* null terminate */ 1821 if (boot_str[i] != '\0') 1822 cmn_err(CE_WARN, 1823 "boot property string is truncated to %s", kern_str); 1824 } 1825 1826 static void 1827 get_boot_properties(void) 1828 { 1829 extern char hw_provider[]; 1830 dev_info_t *devi; 1831 char *name; 1832 int length, flags; 1833 char property_name[50], property_val[50]; 1834 void *bop_staging_area; 1835 1836 bop_staging_area = kmem_zalloc(MMU_PAGESIZE, KM_NOSLEEP); 1837 1838 /* 1839 * Import "root" properties from the boot. 1840 * 1841 * We do this by invoking BOP_NEXTPROP until the list 1842 * is completely copied in. 1843 */ 1844 1845 devi = ddi_root_node(); 1846 for (name = BOP_NEXTPROP(bootops, ""); /* get first */ 1847 name; /* NULL => DONE */ 1848 name = BOP_NEXTPROP(bootops, name)) { /* get next */ 1849 1850 /* copy string to memory above kernelbase */ 1851 copy_boot_str(name, property_name, 50); 1852 1853 /* 1854 * Skip vga properties. They will be picked up later 1855 * by get_vga_properties. 1856 */ 1857 if (strcmp(property_name, "display-edif-block") == 0 || 1858 strcmp(property_name, "display-edif-id") == 0) { 1859 continue; 1860 } 1861 1862 length = BOP_GETPROPLEN(bootops, property_name); 1863 if (length < 0) 1864 continue; 1865 if (length > MMU_PAGESIZE) { 1866 cmn_err(CE_NOTE, 1867 "boot property %s longer than 0x%x, ignored\n", 1868 property_name, MMU_PAGESIZE); 1869 continue; 1870 } 1871 BOP_GETPROP(bootops, property_name, bop_staging_area); 1872 flags = do_bsys_getproptype(bootops, property_name); 1873 1874 /* 1875 * special properties: 1876 * si-machine, si-hw-provider 1877 * goes to kernel data structures. 1878 * bios-boot-device and stdout 1879 * goes to hardware property list so it may show up 1880 * in the prtconf -vp output. This is needed by 1881 * Install/Upgrade. Once we fix install upgrade, 1882 * this can be taken out. 1883 */ 1884 if (strcmp(name, "si-machine") == 0) { 1885 (void) strncpy(utsname.machine, bop_staging_area, 1886 SYS_NMLN); 1887 utsname.machine[SYS_NMLN - 1] = '\0'; 1888 continue; 1889 } 1890 if (strcmp(name, "si-hw-provider") == 0) { 1891 (void) strncpy(hw_provider, bop_staging_area, SYS_NMLN); 1892 hw_provider[SYS_NMLN - 1] = '\0'; 1893 continue; 1894 } 1895 if (strcmp(name, "bios-boot-device") == 0) { 1896 copy_boot_str(bop_staging_area, property_val, 50); 1897 (void) ndi_prop_update_string(DDI_DEV_T_NONE, devi, 1898 property_name, property_val); 1899 continue; 1900 } 1901 if (strcmp(name, "stdout") == 0) { 1902 (void) ndi_prop_update_int(DDI_DEV_T_NONE, devi, 1903 property_name, *((int *)bop_staging_area)); 1904 continue; 1905 } 1906 1907 /* Boolean property */ 1908 if (length == 0) { 1909 (void) e_ddi_prop_create(DDI_DEV_T_NONE, devi, 1910 DDI_PROP_CANSLEEP, property_name, NULL, 0); 1911 continue; 1912 } 1913 1914 /* Now anything else based on type. */ 1915 switch (flags) { 1916 case DDI_PROP_TYPE_INT: 1917 if (length == sizeof (int)) { 1918 (void) e_ddi_prop_update_int(DDI_DEV_T_NONE, 1919 devi, property_name, 1920 *((int *)bop_staging_area)); 1921 } else { 1922 (void) e_ddi_prop_update_int_array( 1923 DDI_DEV_T_NONE, devi, property_name, 1924 bop_staging_area, length / sizeof (int)); 1925 } 1926 break; 1927 case DDI_PROP_TYPE_STRING: 1928 (void) e_ddi_prop_update_string(DDI_DEV_T_NONE, devi, 1929 property_name, bop_staging_area); 1930 break; 1931 case DDI_PROP_TYPE_BYTE: 1932 (void) e_ddi_prop_update_byte_array(DDI_DEV_T_NONE, 1933 devi, property_name, bop_staging_area, length); 1934 break; 1935 case DDI_PROP_TYPE_INT64: 1936 if (length == sizeof (int64_t)) { 1937 (void) e_ddi_prop_update_int64(DDI_DEV_T_NONE, 1938 devi, property_name, 1939 *((int64_t *)bop_staging_area)); 1940 } else { 1941 (void) e_ddi_prop_update_int64_array( 1942 DDI_DEV_T_NONE, devi, property_name, 1943 bop_staging_area, 1944 length / sizeof (int64_t)); 1945 } 1946 break; 1947 default: 1948 /* Property type unknown, use old prop interface */ 1949 (void) e_ddi_prop_create(DDI_DEV_T_NONE, devi, 1950 DDI_PROP_CANSLEEP, property_name, bop_staging_area, 1951 length); 1952 } 1953 } 1954 1955 kmem_free(bop_staging_area, MMU_PAGESIZE); 1956 } 1957 1958 static void 1959 get_vga_properties(void) 1960 { 1961 dev_info_t *devi; 1962 major_t major; 1963 char *name; 1964 int length; 1965 char property_val[50]; 1966 void *bop_staging_area; 1967 1968 /* 1969 * XXXX Hack Allert! 1970 * There really needs to be a better way for identifying various 1971 * console framebuffers and their related issues. Till then, 1972 * check for this one as a replacement to vgatext. 1973 */ 1974 major = ddi_name_to_major("ragexl"); 1975 if (major == (major_t)-1) { 1976 major = ddi_name_to_major("vgatext"); 1977 if (major == (major_t)-1) 1978 return; 1979 } 1980 devi = devnamesp[major].dn_head; 1981 if (devi == NULL) 1982 return; 1983 1984 bop_staging_area = kmem_zalloc(MMU_PAGESIZE, KM_SLEEP); 1985 1986 /* 1987 * Import "vga" properties from the boot. 1988 */ 1989 name = "display-edif-block"; 1990 length = BOP_GETPROPLEN(bootops, name); 1991 if (length > 0 && length < MMU_PAGESIZE) { 1992 BOP_GETPROP(bootops, name, bop_staging_area); 1993 (void) ndi_prop_update_byte_array(DDI_DEV_T_NONE, 1994 devi, name, bop_staging_area, length); 1995 } 1996 1997 /* 1998 * kdmconfig is also looking for display-type and 1999 * video-adapter-type. We default to color and svga. 2000 * 2001 * Could it be "monochrome", "vga"? 2002 * Nah, you've got to come to the 21st century... 2003 * And you can set monitor type manually in kdmconfig 2004 * if you are really an old junky. 2005 */ 2006 (void) ndi_prop_update_string(DDI_DEV_T_NONE, 2007 devi, "display-type", "color"); 2008 (void) ndi_prop_update_string(DDI_DEV_T_NONE, 2009 devi, "video-adapter-type", "svga"); 2010 2011 name = "display-edif-id"; 2012 length = BOP_GETPROPLEN(bootops, name); 2013 if (length > 0 && length < MMU_PAGESIZE) { 2014 BOP_GETPROP(bootops, name, bop_staging_area); 2015 copy_boot_str(bop_staging_area, property_val, length); 2016 (void) ndi_prop_update_string(DDI_DEV_T_NONE, 2017 devi, name, property_val); 2018 } 2019 2020 kmem_free(bop_staging_area, MMU_PAGESIZE); 2021 } 2022 2023 /* 2024 * Copy console font to kernel memory. The temporary font setup 2025 * to use font module was done in early console setup, using low 2026 * memory and data from font module. Now we need to allocate 2027 * kernel memory and copy data over, so the low memory can be freed. 2028 * We can have at most one entry in font list from early boot. 2029 */ 2030 static void 2031 get_console_font(void) 2032 { 2033 struct fontlist *fp, *fl; 2034 bitmap_data_t *bd; 2035 struct font *fd, *tmp; 2036 int i; 2037 2038 if (STAILQ_EMPTY(&fonts)) 2039 return; 2040 2041 fl = STAILQ_FIRST(&fonts); 2042 STAILQ_REMOVE_HEAD(&fonts, font_next); 2043 fp = kmem_zalloc(sizeof (*fp), KM_SLEEP); 2044 bd = kmem_zalloc(sizeof (*bd), KM_SLEEP); 2045 fd = kmem_zalloc(sizeof (*fd), KM_SLEEP); 2046 2047 fp->font_name = NULL; 2048 fp->font_flags = FONT_BOOT; 2049 fp->font_data = bd; 2050 2051 bd->width = fl->font_data->width; 2052 bd->height = fl->font_data->height; 2053 bd->uncompressed_size = fl->font_data->uncompressed_size; 2054 bd->font = fd; 2055 2056 tmp = fl->font_data->font; 2057 fd->vf_width = tmp->vf_width; 2058 fd->vf_height = tmp->vf_height; 2059 for (i = 0; i < VFNT_MAPS; i++) { 2060 if (tmp->vf_map_count[i] == 0) 2061 continue; 2062 fd->vf_map_count[i] = tmp->vf_map_count[i]; 2063 fd->vf_map[i] = kmem_alloc(fd->vf_map_count[i] * 2064 sizeof (*fd->vf_map[i]), KM_SLEEP); 2065 bcopy(tmp->vf_map[i], fd->vf_map[i], fd->vf_map_count[i] * 2066 sizeof (*fd->vf_map[i])); 2067 } 2068 fd->vf_bytes = kmem_alloc(bd->uncompressed_size, KM_SLEEP); 2069 bcopy(tmp->vf_bytes, fd->vf_bytes, bd->uncompressed_size); 2070 STAILQ_INSERT_HEAD(&fonts, fp, font_next); 2071 } 2072 2073 /* 2074 * This is temporary, but absolutely necessary. If we are being 2075 * booted with a device tree created by the DevConf project's bootconf 2076 * program, then we have device information nodes that reflect 2077 * reality. At this point in time in the Solaris release schedule, the 2078 * kernel drivers aren't prepared for reality. They still depend on their 2079 * own ad-hoc interpretations of the properties created when their .conf 2080 * files were interpreted. These drivers use an "ignore-hardware-nodes" 2081 * property to prevent them from using the nodes passed up from the bootconf 2082 * device tree. 2083 * 2084 * Trying to assemble root file system drivers as we are booting from 2085 * devconf will fail if the kernel driver is basing its name_addr's on the 2086 * psuedo-node device info while the bootpath passed up from bootconf is using 2087 * reality-based name_addrs. We help the boot along in this case by 2088 * looking at the pre-bootconf bootpath and determining if we would have 2089 * successfully matched if that had been the bootpath we had chosen. 2090 * 2091 * Note that we only even perform this extra check if we've booted 2092 * using bootconf's 1275 compliant bootpath, this is the boot device, and 2093 * we're trying to match the name_addr specified in the 1275 bootpath. 2094 */ 2095 2096 #define MAXCOMPONENTLEN 32 2097 2098 int 2099 x86_old_bootpath_name_addr_match(dev_info_t *cdip, char *caddr, char *naddr) 2100 { 2101 /* 2102 * There are multiple criteria to be met before we can even 2103 * consider allowing a name_addr match here. 2104 * 2105 * 1) We must have been booted such that the bootconf program 2106 * created device tree nodes and properties. This can be 2107 * determined by examining the 'bootpath' property. This 2108 * property will be a non-null string iff bootconf was 2109 * involved in the boot. 2110 * 2111 * 2) The module that we want to match must be the boot device. 2112 * 2113 * 3) The instance of the module we are thinking of letting be 2114 * our match must be ignoring hardware nodes. 2115 * 2116 * 4) The name_addr we want to match must be the name_addr 2117 * specified in the 1275 bootpath. 2118 */ 2119 static char bootdev_module[MAXCOMPONENTLEN]; 2120 static char bootdev_oldmod[MAXCOMPONENTLEN]; 2121 static char bootdev_newaddr[MAXCOMPONENTLEN]; 2122 static char bootdev_oldaddr[MAXCOMPONENTLEN]; 2123 static int quickexit; 2124 2125 char *daddr; 2126 int dlen; 2127 2128 char *lkupname; 2129 int rv = DDI_FAILURE; 2130 2131 if ((ddi_getlongprop(DDI_DEV_T_ANY, cdip, DDI_PROP_DONTPASS, 2132 "devconf-addr", (caddr_t)&daddr, &dlen) == DDI_PROP_SUCCESS) && 2133 (ddi_getprop(DDI_DEV_T_ANY, cdip, DDI_PROP_DONTPASS, 2134 "ignore-hardware-nodes", -1) != -1)) { 2135 if (strcmp(daddr, caddr) == 0) { 2136 return (DDI_SUCCESS); 2137 } 2138 } 2139 2140 if (quickexit) 2141 return (rv); 2142 2143 if (bootdev_module[0] == '\0') { 2144 char *addrp, *eoaddrp; 2145 char *busp, *modp, *atp; 2146 char *bp1275, *bp; 2147 int bp1275len, bplen; 2148 2149 bp1275 = bp = addrp = eoaddrp = busp = modp = atp = NULL; 2150 2151 if (ddi_getlongprop(DDI_DEV_T_ANY, 2152 ddi_root_node(), 0, "bootpath", 2153 (caddr_t)&bp1275, &bp1275len) != DDI_PROP_SUCCESS || 2154 bp1275len <= 1) { 2155 /* 2156 * We didn't boot from bootconf so we never need to 2157 * do any special matches. 2158 */ 2159 quickexit = 1; 2160 if (bp1275) 2161 kmem_free(bp1275, bp1275len); 2162 return (rv); 2163 } 2164 2165 if (ddi_getlongprop(DDI_DEV_T_ANY, 2166 ddi_root_node(), 0, "boot-path", 2167 (caddr_t)&bp, &bplen) != DDI_PROP_SUCCESS || bplen <= 1) { 2168 /* 2169 * No fallback position for matching. This is 2170 * certainly unexpected, but we'll handle it 2171 * just in case. 2172 */ 2173 quickexit = 1; 2174 kmem_free(bp1275, bp1275len); 2175 if (bp) 2176 kmem_free(bp, bplen); 2177 return (rv); 2178 } 2179 2180 /* 2181 * Determine boot device module and 1275 name_addr 2182 * 2183 * bootpath assumed to be of the form /bus/module@name_addr 2184 */ 2185 if ((busp = strchr(bp1275, '/')) != NULL) { 2186 if ((modp = strchr(busp + 1, '/')) != NULL) { 2187 if ((atp = strchr(modp + 1, '@')) != NULL) { 2188 *atp = '\0'; 2189 addrp = atp + 1; 2190 if ((eoaddrp = strchr(addrp, '/')) != 2191 NULL) 2192 *eoaddrp = '\0'; 2193 } 2194 } 2195 } 2196 2197 if (modp && addrp) { 2198 (void) strncpy(bootdev_module, modp + 1, 2199 MAXCOMPONENTLEN); 2200 bootdev_module[MAXCOMPONENTLEN - 1] = '\0'; 2201 2202 (void) strncpy(bootdev_newaddr, addrp, MAXCOMPONENTLEN); 2203 bootdev_newaddr[MAXCOMPONENTLEN - 1] = '\0'; 2204 } else { 2205 quickexit = 1; 2206 kmem_free(bp1275, bp1275len); 2207 kmem_free(bp, bplen); 2208 return (rv); 2209 } 2210 2211 /* 2212 * Determine fallback name_addr 2213 * 2214 * 10/3/96 - Also save fallback module name because it 2215 * might actually be different than the current module 2216 * name. E.G., ISA pnp drivers have new names. 2217 * 2218 * bootpath assumed to be of the form /bus/module@name_addr 2219 */ 2220 addrp = NULL; 2221 if ((busp = strchr(bp, '/')) != NULL) { 2222 if ((modp = strchr(busp + 1, '/')) != NULL) { 2223 if ((atp = strchr(modp + 1, '@')) != NULL) { 2224 *atp = '\0'; 2225 addrp = atp + 1; 2226 if ((eoaddrp = strchr(addrp, '/')) != 2227 NULL) 2228 *eoaddrp = '\0'; 2229 } 2230 } 2231 } 2232 2233 if (modp && addrp) { 2234 (void) strncpy(bootdev_oldmod, modp + 1, 2235 MAXCOMPONENTLEN); 2236 bootdev_module[MAXCOMPONENTLEN - 1] = '\0'; 2237 2238 (void) strncpy(bootdev_oldaddr, addrp, MAXCOMPONENTLEN); 2239 bootdev_oldaddr[MAXCOMPONENTLEN - 1] = '\0'; 2240 } 2241 2242 /* Free up the bootpath storage now that we're done with it. */ 2243 kmem_free(bp1275, bp1275len); 2244 kmem_free(bp, bplen); 2245 2246 if (bootdev_oldaddr[0] == '\0') { 2247 quickexit = 1; 2248 return (rv); 2249 } 2250 } 2251 2252 if (((lkupname = ddi_get_name(cdip)) != NULL) && 2253 (strcmp(bootdev_module, lkupname) == 0 || 2254 strcmp(bootdev_oldmod, lkupname) == 0) && 2255 ((ddi_getprop(DDI_DEV_T_ANY, cdip, DDI_PROP_DONTPASS, 2256 "ignore-hardware-nodes", -1) != -1) || 2257 ignore_hardware_nodes) && 2258 strcmp(bootdev_newaddr, caddr) == 0 && 2259 strcmp(bootdev_oldaddr, naddr) == 0) { 2260 rv = DDI_SUCCESS; 2261 } 2262 2263 return (rv); 2264 } 2265 2266 /* 2267 * Perform a copy from a memory mapped device (whose devinfo pointer is devi) 2268 * separately mapped at devaddr in the kernel to a kernel buffer at kaddr. 2269 */ 2270 /*ARGSUSED*/ 2271 int 2272 e_ddi_copyfromdev(dev_info_t *devi, 2273 off_t off, const void *devaddr, void *kaddr, size_t len) 2274 { 2275 bcopy(devaddr, kaddr, len); 2276 return (0); 2277 } 2278 2279 /* 2280 * Perform a copy to a memory mapped device (whose devinfo pointer is devi) 2281 * separately mapped at devaddr in the kernel from a kernel buffer at kaddr. 2282 */ 2283 /*ARGSUSED*/ 2284 int 2285 e_ddi_copytodev(dev_info_t *devi, 2286 off_t off, const void *kaddr, void *devaddr, size_t len) 2287 { 2288 bcopy(kaddr, devaddr, len); 2289 return (0); 2290 } 2291 2292 2293 static int 2294 poke_mem(peekpoke_ctlops_t *in_args) 2295 { 2296 int err; 2297 on_trap_data_t otd; 2298 2299 /* Set up protected environment. */ 2300 if (!on_trap(&otd, OT_DATA_ACCESS)) { 2301 err = DDI_SUCCESS; 2302 switch (in_args->size) { 2303 case sizeof (uint8_t): 2304 *(uint8_t *)(in_args->dev_addr) = 2305 *(uint8_t *)in_args->host_addr; 2306 break; 2307 2308 case sizeof (uint16_t): 2309 *(uint16_t *)(in_args->dev_addr) = 2310 *(uint16_t *)in_args->host_addr; 2311 break; 2312 2313 case sizeof (uint32_t): 2314 *(uint32_t *)(in_args->dev_addr) = 2315 *(uint32_t *)in_args->host_addr; 2316 break; 2317 2318 case sizeof (uint64_t): 2319 *(uint64_t *)(in_args->dev_addr) = 2320 *(uint64_t *)in_args->host_addr; 2321 break; 2322 2323 default: 2324 err = DDI_FAILURE; 2325 break; 2326 } 2327 } else { 2328 err = DDI_FAILURE; 2329 } 2330 2331 /* Take down protected environment. */ 2332 no_trap(); 2333 2334 return (err); 2335 } 2336 2337 2338 static int 2339 peek_mem(peekpoke_ctlops_t *in_args) 2340 { 2341 int err; 2342 on_trap_data_t otd; 2343 2344 if (!on_trap(&otd, OT_DATA_ACCESS)) { 2345 err = DDI_SUCCESS; 2346 switch (in_args->size) { 2347 case sizeof (uint8_t): 2348 *(uint8_t *)in_args->host_addr = 2349 *(uint8_t *)in_args->dev_addr; 2350 break; 2351 2352 case sizeof (uint16_t): 2353 *(uint16_t *)in_args->host_addr = 2354 *(uint16_t *)in_args->dev_addr; 2355 break; 2356 2357 case sizeof (uint32_t): 2358 *(uint32_t *)in_args->host_addr = 2359 *(uint32_t *)in_args->dev_addr; 2360 break; 2361 2362 case sizeof (uint64_t): 2363 *(uint64_t *)in_args->host_addr = 2364 *(uint64_t *)in_args->dev_addr; 2365 break; 2366 2367 default: 2368 err = DDI_FAILURE; 2369 break; 2370 } 2371 } else { 2372 err = DDI_FAILURE; 2373 } 2374 2375 no_trap(); 2376 return (err); 2377 } 2378 2379 2380 /* 2381 * This is called only to process peek/poke when the DIP is NULL. 2382 * Assume that this is for memory, as nexi take care of device safe accesses. 2383 */ 2384 int 2385 peekpoke_mem(ddi_ctl_enum_t cmd, peekpoke_ctlops_t *in_args) 2386 { 2387 return (cmd == DDI_CTLOPS_PEEK ? peek_mem(in_args) : poke_mem(in_args)); 2388 } 2389 2390 /* 2391 * we've just done a cautious put/get. Check if it was successful by 2392 * calling pci_ereport_post() on all puts and for any gets that return -1 2393 */ 2394 static int 2395 pci_peekpoke_check_fma(dev_info_t *dip, void *arg, ddi_ctl_enum_t ctlop, 2396 void (*scan)(dev_info_t *, ddi_fm_error_t *)) 2397 { 2398 int rval = DDI_SUCCESS; 2399 peekpoke_ctlops_t *in_args = (peekpoke_ctlops_t *)arg; 2400 ddi_fm_error_t de; 2401 ddi_acc_impl_t *hp = (ddi_acc_impl_t *)in_args->handle; 2402 ddi_acc_hdl_t *hdlp = (ddi_acc_hdl_t *)in_args->handle; 2403 int check_err = 0; 2404 int repcount = in_args->repcount; 2405 2406 if (ctlop == DDI_CTLOPS_POKE && 2407 hdlp->ah_acc.devacc_attr_access != DDI_CAUTIOUS_ACC) 2408 return (DDI_SUCCESS); 2409 2410 if (ctlop == DDI_CTLOPS_PEEK && 2411 hdlp->ah_acc.devacc_attr_access != DDI_CAUTIOUS_ACC) { 2412 for (; repcount; repcount--) { 2413 switch (in_args->size) { 2414 case sizeof (uint8_t): 2415 if (*(uint8_t *)in_args->host_addr == 0xff) 2416 check_err = 1; 2417 break; 2418 case sizeof (uint16_t): 2419 if (*(uint16_t *)in_args->host_addr == 0xffff) 2420 check_err = 1; 2421 break; 2422 case sizeof (uint32_t): 2423 if (*(uint32_t *)in_args->host_addr == 2424 0xffffffff) 2425 check_err = 1; 2426 break; 2427 case sizeof (uint64_t): 2428 if (*(uint64_t *)in_args->host_addr == 2429 0xffffffffffffffff) 2430 check_err = 1; 2431 break; 2432 } 2433 } 2434 if (check_err == 0) 2435 return (DDI_SUCCESS); 2436 } 2437 /* 2438 * for a cautious put or get or a non-cautious get that returned -1 call 2439 * io framework to see if there really was an error 2440 */ 2441 bzero(&de, sizeof (ddi_fm_error_t)); 2442 de.fme_version = DDI_FME_VERSION; 2443 de.fme_ena = fm_ena_generate(0, FM_ENA_FMT1); 2444 if (hdlp->ah_acc.devacc_attr_access == DDI_CAUTIOUS_ACC) { 2445 de.fme_flag = DDI_FM_ERR_EXPECTED; 2446 de.fme_acc_handle = in_args->handle; 2447 } else if (hdlp->ah_acc.devacc_attr_access == DDI_DEFAULT_ACC) { 2448 /* 2449 * We only get here with DDI_DEFAULT_ACC for config space gets. 2450 * Non-hardened drivers may be probing the hardware and 2451 * expecting -1 returned. So need to treat errors on 2452 * DDI_DEFAULT_ACC as DDI_FM_ERR_EXPECTED. 2453 */ 2454 de.fme_flag = DDI_FM_ERR_EXPECTED; 2455 de.fme_acc_handle = in_args->handle; 2456 } else { 2457 /* 2458 * Hardened driver doing protected accesses shouldn't 2459 * get errors unless there's a hardware problem. Treat 2460 * as nonfatal if there's an error, but set UNEXPECTED 2461 * so we raise ereports on any errors and potentially 2462 * fault the device 2463 */ 2464 de.fme_flag = DDI_FM_ERR_UNEXPECTED; 2465 } 2466 (void) scan(dip, &de); 2467 if (hdlp->ah_acc.devacc_attr_access != DDI_DEFAULT_ACC && 2468 de.fme_status != DDI_FM_OK) { 2469 ndi_err_t *errp = (ndi_err_t *)hp->ahi_err; 2470 rval = DDI_FAILURE; 2471 errp->err_ena = de.fme_ena; 2472 errp->err_expected = de.fme_flag; 2473 errp->err_status = DDI_FM_NONFATAL; 2474 } 2475 return (rval); 2476 } 2477 2478 /* 2479 * pci_peekpoke_check_nofma() is for when an error occurs on a register access 2480 * during pci_ereport_post(). We can't call pci_ereport_post() again or we'd 2481 * recurse, so assume all puts are OK and gets have failed if they return -1 2482 */ 2483 static int 2484 pci_peekpoke_check_nofma(void *arg, ddi_ctl_enum_t ctlop) 2485 { 2486 int rval = DDI_SUCCESS; 2487 peekpoke_ctlops_t *in_args = (peekpoke_ctlops_t *)arg; 2488 ddi_acc_impl_t *hp = (ddi_acc_impl_t *)in_args->handle; 2489 ddi_acc_hdl_t *hdlp = (ddi_acc_hdl_t *)in_args->handle; 2490 int repcount = in_args->repcount; 2491 2492 if (ctlop == DDI_CTLOPS_POKE) 2493 return (rval); 2494 2495 for (; repcount; repcount--) { 2496 switch (in_args->size) { 2497 case sizeof (uint8_t): 2498 if (*(uint8_t *)in_args->host_addr == 0xff) 2499 rval = DDI_FAILURE; 2500 break; 2501 case sizeof (uint16_t): 2502 if (*(uint16_t *)in_args->host_addr == 0xffff) 2503 rval = DDI_FAILURE; 2504 break; 2505 case sizeof (uint32_t): 2506 if (*(uint32_t *)in_args->host_addr == 0xffffffff) 2507 rval = DDI_FAILURE; 2508 break; 2509 case sizeof (uint64_t): 2510 if (*(uint64_t *)in_args->host_addr == 2511 0xffffffffffffffff) 2512 rval = DDI_FAILURE; 2513 break; 2514 } 2515 } 2516 if (hdlp->ah_acc.devacc_attr_access != DDI_DEFAULT_ACC && 2517 rval == DDI_FAILURE) { 2518 ndi_err_t *errp = (ndi_err_t *)hp->ahi_err; 2519 errp->err_ena = fm_ena_generate(0, FM_ENA_FMT1); 2520 errp->err_expected = DDI_FM_ERR_UNEXPECTED; 2521 errp->err_status = DDI_FM_NONFATAL; 2522 } 2523 return (rval); 2524 } 2525 2526 int 2527 pci_peekpoke_check(dev_info_t *dip, dev_info_t *rdip, 2528 ddi_ctl_enum_t ctlop, void *arg, void *result, 2529 int (*handler)(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *, 2530 void *), kmutex_t *err_mutexp, kmutex_t *peek_poke_mutexp, 2531 void (*scan)(dev_info_t *, ddi_fm_error_t *)) 2532 { 2533 int rval; 2534 peekpoke_ctlops_t *in_args = (peekpoke_ctlops_t *)arg; 2535 ddi_acc_impl_t *hp = (ddi_acc_impl_t *)in_args->handle; 2536 2537 /* 2538 * this function only supports cautious accesses, not peeks/pokes 2539 * which don't have a handle 2540 */ 2541 if (hp == NULL) 2542 return (DDI_FAILURE); 2543 2544 if (hp->ahi_acc_attr & DDI_ACCATTR_CONFIG_SPACE) { 2545 if (!mutex_tryenter(err_mutexp)) { 2546 /* 2547 * As this may be a recursive call from within 2548 * pci_ereport_post() we can't wait for the mutexes. 2549 * Fortunately we know someone is already calling 2550 * pci_ereport_post() which will handle the error bits 2551 * for us, and as this is a config space access we can 2552 * just do the access and check return value for -1 2553 * using pci_peekpoke_check_nofma(). 2554 */ 2555 rval = handler(dip, rdip, ctlop, arg, result); 2556 if (rval == DDI_SUCCESS) 2557 rval = pci_peekpoke_check_nofma(arg, ctlop); 2558 return (rval); 2559 } 2560 /* 2561 * This can't be a recursive call. Drop the err_mutex and get 2562 * both mutexes in the right order. If an error hasn't already 2563 * been detected by the ontrap code, use pci_peekpoke_check_fma 2564 * which will call pci_ereport_post() to check error status. 2565 */ 2566 mutex_exit(err_mutexp); 2567 } 2568 mutex_enter(peek_poke_mutexp); 2569 rval = handler(dip, rdip, ctlop, arg, result); 2570 if (rval == DDI_SUCCESS) { 2571 mutex_enter(err_mutexp); 2572 rval = pci_peekpoke_check_fma(dip, arg, ctlop, scan); 2573 mutex_exit(err_mutexp); 2574 } 2575 mutex_exit(peek_poke_mutexp); 2576 return (rval); 2577 } 2578 2579 void 2580 impl_setup_ddi(void) 2581 { 2582 #if !defined(__xpv) 2583 extern void startup_bios_disk(void); 2584 extern int post_fastreboot; 2585 #endif 2586 dev_info_t *xdip, *isa_dip; 2587 rd_existing_t rd_mem_prop; 2588 int err; 2589 2590 ndi_devi_alloc_sleep(ddi_root_node(), "ramdisk", 2591 (pnode_t)DEVI_SID_NODEID, &xdip); 2592 2593 (void) BOP_GETPROP(bootops, 2594 "ramdisk_start", (void *)&ramdisk_start); 2595 (void) BOP_GETPROP(bootops, 2596 "ramdisk_end", (void *)&ramdisk_end); 2597 2598 #ifdef __xpv 2599 ramdisk_start -= ONE_GIG; 2600 ramdisk_end -= ONE_GIG; 2601 #endif 2602 rd_mem_prop.phys = ramdisk_start; 2603 rd_mem_prop.size = ramdisk_end - ramdisk_start + 1; 2604 2605 (void) ndi_prop_update_byte_array(DDI_DEV_T_NONE, xdip, 2606 RD_EXISTING_PROP_NAME, (uchar_t *)&rd_mem_prop, 2607 sizeof (rd_mem_prop)); 2608 err = ndi_devi_bind_driver(xdip, 0); 2609 ASSERT(err == 0); 2610 2611 /* isa node */ 2612 if (pseudo_isa) { 2613 ndi_devi_alloc_sleep(ddi_root_node(), "isa", 2614 (pnode_t)DEVI_SID_NODEID, &isa_dip); 2615 (void) ndi_prop_update_string(DDI_DEV_T_NONE, isa_dip, 2616 "device_type", "isa"); 2617 (void) ndi_prop_update_string(DDI_DEV_T_NONE, isa_dip, 2618 "bus-type", "isa"); 2619 (void) ndi_devi_bind_driver(isa_dip, 0); 2620 } 2621 2622 /* 2623 * Read in the properties from the boot. 2624 */ 2625 get_boot_properties(); 2626 2627 /* not framebuffer should be enumerated, if present */ 2628 get_vga_properties(); 2629 2630 /* Copy console font if provided by boot. */ 2631 get_console_font(); 2632 2633 /* 2634 * Check for administratively disabled drivers. 2635 */ 2636 check_driver_disable(); 2637 2638 #if !defined(__xpv) 2639 if (!post_fastreboot && BOP_GETPROPLEN(bootops, "efi-systab") < 0) 2640 startup_bios_disk(); 2641 #endif 2642 /* do bus dependent probes. */ 2643 impl_bus_initialprobe(); 2644 } 2645 2646 dev_t 2647 getrootdev(void) 2648 { 2649 /* 2650 * Usually rootfs.bo_name is initialized by the 2651 * the bootpath property from bootenv.rc, but 2652 * defaults to "/ramdisk:a" otherwise. 2653 */ 2654 return (ddi_pathname_to_dev_t(rootfs.bo_name)); 2655 } 2656 2657 static struct bus_probe { 2658 struct bus_probe *next; 2659 void (*probe)(int); 2660 } *bus_probes; 2661 2662 void 2663 impl_bus_add_probe(void (*func)(int)) 2664 { 2665 struct bus_probe *probe; 2666 struct bus_probe *lastprobe = NULL; 2667 2668 probe = kmem_alloc(sizeof (*probe), KM_SLEEP); 2669 probe->probe = func; 2670 probe->next = NULL; 2671 2672 if (!bus_probes) { 2673 bus_probes = probe; 2674 return; 2675 } 2676 2677 lastprobe = bus_probes; 2678 while (lastprobe->next) 2679 lastprobe = lastprobe->next; 2680 lastprobe->next = probe; 2681 } 2682 2683 /*ARGSUSED*/ 2684 void 2685 impl_bus_delete_probe(void (*func)(int)) 2686 { 2687 struct bus_probe *prev = NULL; 2688 struct bus_probe *probe = bus_probes; 2689 2690 while (probe) { 2691 if (probe->probe == func) 2692 break; 2693 prev = probe; 2694 probe = probe->next; 2695 } 2696 2697 if (probe == NULL) 2698 return; 2699 2700 if (prev) 2701 prev->next = probe->next; 2702 else 2703 bus_probes = probe->next; 2704 2705 kmem_free(probe, sizeof (struct bus_probe)); 2706 } 2707 2708 /* 2709 * impl_bus_initialprobe 2710 * Modload the prom simulator, then let it probe to verify existence 2711 * and type of PCI support. 2712 */ 2713 static void 2714 impl_bus_initialprobe(void) 2715 { 2716 struct bus_probe *probe; 2717 2718 /* load modules to install bus probes */ 2719 #if defined(__xpv) 2720 if (DOMAIN_IS_INITDOMAIN(xen_info)) { 2721 if (modload("misc", "pci_autoconfig") < 0) { 2722 panic("failed to load misc/pci_autoconfig"); 2723 } 2724 2725 if (modload("drv", "isa") < 0) 2726 panic("failed to load drv/isa"); 2727 } 2728 2729 (void) modload("misc", "xpv_autoconfig"); 2730 #else 2731 if (modload("misc", "pci_autoconfig") < 0) { 2732 panic("failed to load misc/pci_autoconfig"); 2733 } 2734 2735 (void) modload("misc", "acpidev"); 2736 2737 if (modload("drv", "isa") < 0) 2738 panic("failed to load drv/isa"); 2739 #endif 2740 2741 probe = bus_probes; 2742 while (probe) { 2743 /* run the probe functions */ 2744 (*probe->probe)(0); 2745 probe = probe->next; 2746 } 2747 } 2748 2749 /* 2750 * impl_bus_reprobe 2751 * Reprogram devices not set up by firmware. 2752 */ 2753 static void 2754 impl_bus_reprobe(void) 2755 { 2756 struct bus_probe *probe; 2757 2758 probe = bus_probes; 2759 while (probe) { 2760 /* run the probe function */ 2761 (*probe->probe)(1); 2762 probe = probe->next; 2763 } 2764 } 2765 2766 2767 /* 2768 * The following functions ready a cautious request to go up to the nexus 2769 * driver. It is up to the nexus driver to decide how to process the request. 2770 * It may choose to call i_ddi_do_caut_get/put in this file, or do it 2771 * differently. 2772 */ 2773 2774 static void 2775 i_ddi_caut_getput_ctlops(ddi_acc_impl_t *hp, uint64_t host_addr, 2776 uint64_t dev_addr, size_t size, size_t repcount, uint_t flags, 2777 ddi_ctl_enum_t cmd) 2778 { 2779 peekpoke_ctlops_t cautacc_ctlops_arg; 2780 2781 cautacc_ctlops_arg.size = size; 2782 cautacc_ctlops_arg.dev_addr = dev_addr; 2783 cautacc_ctlops_arg.host_addr = host_addr; 2784 cautacc_ctlops_arg.handle = (ddi_acc_handle_t)hp; 2785 cautacc_ctlops_arg.repcount = repcount; 2786 cautacc_ctlops_arg.flags = flags; 2787 2788 (void) ddi_ctlops(hp->ahi_common.ah_dip, hp->ahi_common.ah_dip, cmd, 2789 &cautacc_ctlops_arg, NULL); 2790 } 2791 2792 uint8_t 2793 i_ddi_caut_get8(ddi_acc_impl_t *hp, uint8_t *addr) 2794 { 2795 uint8_t value; 2796 i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr, 2797 sizeof (uint8_t), 1, 0, DDI_CTLOPS_PEEK); 2798 2799 return (value); 2800 } 2801 2802 uint16_t 2803 i_ddi_caut_get16(ddi_acc_impl_t *hp, uint16_t *addr) 2804 { 2805 uint16_t value; 2806 i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr, 2807 sizeof (uint16_t), 1, 0, DDI_CTLOPS_PEEK); 2808 2809 return (value); 2810 } 2811 2812 uint32_t 2813 i_ddi_caut_get32(ddi_acc_impl_t *hp, uint32_t *addr) 2814 { 2815 uint32_t value; 2816 i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr, 2817 sizeof (uint32_t), 1, 0, DDI_CTLOPS_PEEK); 2818 2819 return (value); 2820 } 2821 2822 uint64_t 2823 i_ddi_caut_get64(ddi_acc_impl_t *hp, uint64_t *addr) 2824 { 2825 uint64_t value; 2826 i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr, 2827 sizeof (uint64_t), 1, 0, DDI_CTLOPS_PEEK); 2828 2829 return (value); 2830 } 2831 2832 void 2833 i_ddi_caut_put8(ddi_acc_impl_t *hp, uint8_t *addr, uint8_t value) 2834 { 2835 i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr, 2836 sizeof (uint8_t), 1, 0, DDI_CTLOPS_POKE); 2837 } 2838 2839 void 2840 i_ddi_caut_put16(ddi_acc_impl_t *hp, uint16_t *addr, uint16_t value) 2841 { 2842 i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr, 2843 sizeof (uint16_t), 1, 0, DDI_CTLOPS_POKE); 2844 } 2845 2846 void 2847 i_ddi_caut_put32(ddi_acc_impl_t *hp, uint32_t *addr, uint32_t value) 2848 { 2849 i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr, 2850 sizeof (uint32_t), 1, 0, DDI_CTLOPS_POKE); 2851 } 2852 2853 void 2854 i_ddi_caut_put64(ddi_acc_impl_t *hp, uint64_t *addr, uint64_t value) 2855 { 2856 i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr, 2857 sizeof (uint64_t), 1, 0, DDI_CTLOPS_POKE); 2858 } 2859 2860 void 2861 i_ddi_caut_rep_get8(ddi_acc_impl_t *hp, uint8_t *host_addr, uint8_t *dev_addr, 2862 size_t repcount, uint_t flags) 2863 { 2864 i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr, 2865 sizeof (uint8_t), repcount, flags, DDI_CTLOPS_PEEK); 2866 } 2867 2868 void 2869 i_ddi_caut_rep_get16(ddi_acc_impl_t *hp, uint16_t *host_addr, 2870 uint16_t *dev_addr, size_t repcount, uint_t flags) 2871 { 2872 i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr, 2873 sizeof (uint16_t), repcount, flags, DDI_CTLOPS_PEEK); 2874 } 2875 2876 void 2877 i_ddi_caut_rep_get32(ddi_acc_impl_t *hp, uint32_t *host_addr, 2878 uint32_t *dev_addr, size_t repcount, uint_t flags) 2879 { 2880 i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr, 2881 sizeof (uint32_t), repcount, flags, DDI_CTLOPS_PEEK); 2882 } 2883 2884 void 2885 i_ddi_caut_rep_get64(ddi_acc_impl_t *hp, uint64_t *host_addr, 2886 uint64_t *dev_addr, size_t repcount, uint_t flags) 2887 { 2888 i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr, 2889 sizeof (uint64_t), repcount, flags, DDI_CTLOPS_PEEK); 2890 } 2891 2892 void 2893 i_ddi_caut_rep_put8(ddi_acc_impl_t *hp, uint8_t *host_addr, uint8_t *dev_addr, 2894 size_t repcount, uint_t flags) 2895 { 2896 i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr, 2897 sizeof (uint8_t), repcount, flags, DDI_CTLOPS_POKE); 2898 } 2899 2900 void 2901 i_ddi_caut_rep_put16(ddi_acc_impl_t *hp, uint16_t *host_addr, 2902 uint16_t *dev_addr, size_t repcount, uint_t flags) 2903 { 2904 i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr, 2905 sizeof (uint16_t), repcount, flags, DDI_CTLOPS_POKE); 2906 } 2907 2908 void 2909 i_ddi_caut_rep_put32(ddi_acc_impl_t *hp, uint32_t *host_addr, 2910 uint32_t *dev_addr, size_t repcount, uint_t flags) 2911 { 2912 i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr, 2913 sizeof (uint32_t), repcount, flags, DDI_CTLOPS_POKE); 2914 } 2915 2916 void 2917 i_ddi_caut_rep_put64(ddi_acc_impl_t *hp, uint64_t *host_addr, 2918 uint64_t *dev_addr, size_t repcount, uint_t flags) 2919 { 2920 i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr, 2921 sizeof (uint64_t), repcount, flags, DDI_CTLOPS_POKE); 2922 } 2923 2924 boolean_t 2925 i_ddi_copybuf_required(ddi_dma_attr_t *attrp) 2926 { 2927 uint64_t hi_pa; 2928 2929 hi_pa = ((uint64_t)physmax + 1ull) << PAGESHIFT; 2930 if (attrp->dma_attr_addr_hi < hi_pa) { 2931 return (B_TRUE); 2932 } 2933 2934 return (B_FALSE); 2935 } 2936 2937 size_t 2938 i_ddi_copybuf_size() 2939 { 2940 return (dma_max_copybuf_size); 2941 } 2942 2943 /* 2944 * i_ddi_dma_max() 2945 * returns the maximum DMA size which can be performed in a single DMA 2946 * window taking into account the devices DMA contraints (attrp), the 2947 * maximum copy buffer size (if applicable), and the worse case buffer 2948 * fragmentation. 2949 */ 2950 /*ARGSUSED*/ 2951 uint32_t 2952 i_ddi_dma_max(dev_info_t *dip, ddi_dma_attr_t *attrp) 2953 { 2954 uint64_t maxxfer; 2955 2956 2957 /* 2958 * take the min of maxxfer and the the worse case fragementation 2959 * (e.g. every cookie <= 1 page) 2960 */ 2961 maxxfer = MIN(attrp->dma_attr_maxxfer, 2962 ((uint64_t)(attrp->dma_attr_sgllen - 1) << PAGESHIFT)); 2963 2964 /* 2965 * If the DMA engine can't reach all off memory, we also need to take 2966 * the max size of the copybuf into consideration. 2967 */ 2968 if (i_ddi_copybuf_required(attrp)) { 2969 maxxfer = MIN(i_ddi_copybuf_size(), maxxfer); 2970 } 2971 2972 /* 2973 * we only return a 32-bit value. Make sure it's not -1. Round to a 2974 * page so it won't be mistaken for an error value during debug. 2975 */ 2976 if (maxxfer >= 0xFFFFFFFF) { 2977 maxxfer = 0xFFFFF000; 2978 } 2979 2980 /* 2981 * make sure the value we return is a whole multiple of the 2982 * granlarity. 2983 */ 2984 if (attrp->dma_attr_granular > 1) { 2985 maxxfer = maxxfer - (maxxfer % attrp->dma_attr_granular); 2986 } 2987 2988 return ((uint32_t)maxxfer); 2989 } 2990 2991 /*ARGSUSED*/ 2992 void 2993 translate_devid(dev_info_t *dip) 2994 { 2995 } 2996 2997 pfn_t 2998 i_ddi_paddr_to_pfn(paddr_t paddr) 2999 { 3000 pfn_t pfn; 3001 3002 #ifdef __xpv 3003 if (DOMAIN_IS_INITDOMAIN(xen_info)) { 3004 pfn = xen_assign_pfn(mmu_btop(paddr)); 3005 } else { 3006 pfn = mmu_btop(paddr); 3007 } 3008 #else 3009 pfn = mmu_btop(paddr); 3010 #endif 3011 3012 return (pfn); 3013 } 3014