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