Lines Matching defs:dhp
88 #define HOLD_DHP_LOCK(dhp) if (dhp->dh_flags & DEVMAP_ALLOW_REMAP) \
89 { mutex_enter(&dhp->dh_lock); }
91 #define RELE_DHP_LOCK(dhp) if (dhp->dh_flags & DEVMAP_ALLOW_REMAP) \
92 { mutex_exit(&dhp->dh_lock); }
151 #define dhp_is_devmem(dhp) \
152 (cookie_is_devmem((struct ddi_umem_cookie *)((dhp)->dh_cookie)))
154 #define dhp_is_pmem(dhp) \
155 (cookie_is_pmem((struct ddi_umem_cookie *)((dhp)->dh_cookie)))
157 #define dhp_is_kpmem(dhp) \
158 (cookie_is_kpmem((struct ddi_umem_cookie *)((dhp)->dh_cookie)))
244 static ulong_t devmap_roundup(devmap_handle_t *dhp, ulong_t offset, size_t len,
247 static void free_devmap_handle(devmap_handle_t *dhp);
249 static int devmap_handle_dup(devmap_handle_t *dhp, devmap_handle_t **new_dhp,
252 static devmap_handle_t *devmap_handle_unmap(devmap_handle_t *dhp);
254 static void devmap_handle_unmap_head(devmap_handle_t *dhp, size_t len);
256 static void devmap_handle_unmap_tail(devmap_handle_t *dhp, caddr_t addr);
258 static int devmap_device(devmap_handle_t *dhp, struct as *as, caddr_t *addr,
261 static void devmap_get_large_pgsize(devmap_handle_t *dhp, size_t len,
264 static void devmap_handle_reduce_len(devmap_handle_t *dhp, size_t len);
335 * within dhp->dh_timeout_length ticks
363 devmap_handle_t *dhp = (devmap_handle_t *)a->devmap_data;
386 sdp->devmap_data = dhp;
388 sdp->devmap_data = dhp = NULL;
409 while (dhp != NULL) {
410 dhp->dh_seg = seg;
411 dhp = dhp->dh_next;
419 * dhp specific maxprot because spec_addmap does not use maxprot.
462 devmap_handle_t *dhp = (devmap_handle_t *)sdp->devmap_data;
467 "segdev_dup:start dhp=%p, seg=%p", (void *)dhp, (void *)seg);
469 DEBUGF(3, (CE_CONT, "segdev_dup: dhp %p seg %p\n",
470 (void *)dhp, (void *)seg));
512 if (dhp != NULL) {
513 ret = devmap_handle_dup(dhp,
517 "segdev_dup:ret1 ret=%x, dhp=%p seg=%p",
518 ret, (void *)dhp, (void *)seg);
520 "segdev_dup: ret %x dhp %p seg %p\n",
521 ret, (void *)dhp, (void *)seg));
539 devmap_handle_dup(devmap_handle_t *dhp, devmap_handle_t **new_dhp,
546 while (dhp != NULL) {
549 /* Need to lock the original dhp while copying if REMAP */
550 HOLD_DHP_LOCK(dhp);
551 bcopy(dhp, newdhp, sizeof (devmap_handle_t));
552 RELE_DHP_LOCK(dhp);
563 if (dhp->dh_softlock != NULL)
567 if (dhp->dh_ctx != NULL)
586 ret = (*callbackops->devmap_dup)(dhp, dhp->dh_pvtp,
601 "newdhp %p dhp %p\n", (void *)newdhp,
602 (void *)dhp));
608 dhp = dhp->dh_next;
628 devmap_handle_t *dhp = (devmap_handle_t *)sdp->devmap_data;
638 "segdev_unmap:start dhp=%p, seg=%p addr=%p len=%lx",
639 (void *)dhp, (void *)seg, (void *)addr, len);
641 DEBUGF(3, (CE_CONT, "segdev_unmap: dhp %p seg %p addr %p len %lx\n",
642 (void *)dhp, (void *)seg, (void *)addr, len));
668 if (dhp != NULL) {
674 dhpp = tdhp = devmap_find_handle(dhp, addr);
681 if (tdhp != NULL) { /* found a dhp using large pages */
751 if (dhp != NULL)
752 devmap_handle_unmap_head(dhp, len);
783 if (dhp != NULL)
784 devmap_handle_unmap_tail(dhp, addr);
853 if (dhp == NULL) {
857 while (dhp != NULL) {
858 callbackops = &dhp->dh_callbackops;
860 "segdev_unmap: dhp=%p addr=%p", dhp, addr);
861 DEBUGF(3, (CE_CONT, "unmap: dhp %p addr %p uvaddr %p len %lx\n",
862 (void *)dhp, (void *)addr,
863 (void *)dhp->dh_uvaddr, dhp->dh_len));
865 if (addr == (dhp->dh_uvaddr + dhp->dh_len)) {
866 dhpp = dhp->dh_next;
867 dhp->dh_next = NULL;
868 dhp = dhpp;
869 } else if (addr > (dhp->dh_uvaddr + dhp->dh_len)) {
870 dhp = dhp->dh_next;
871 } else if (addr > dhp->dh_uvaddr &&
872 (addr + len) < (dhp->dh_uvaddr + dhp->dh_len)) {
874 * <addr, addr+len> is enclosed by dhp.
876 * ends at dhp->dh_uvaddr+dhp->dh_len.
879 HOLD_DHP_LOCK(dhp);
880 bcopy(dhp, newdhp, sizeof (devmap_handle_t));
881 RELE_DHP_LOCK(dhp);
883 newdhp->dh_next = dhp->dh_next;
884 if (dhp->dh_softlock != NULL)
888 if (dhp->dh_ctx != NULL)
896 (*callbackops->devmap_unmap)(dhp, dhp->dh_pvtp,
897 off, len, dhp, &dhp->dh_pvtp,
899 mlen = len + (addr - dhp->dh_uvaddr);
903 dhp->dh_len = addr - dhp->dh_uvaddr;
904 dhpp = dhp->dh_next;
905 dhp->dh_next = NULL;
906 dhp = dhpp;
907 } else if ((addr > dhp->dh_uvaddr) &&
908 ((addr + len) >= (dhp->dh_uvaddr + dhp->dh_len))) {
909 mlen = dhp->dh_len + dhp->dh_uvaddr - addr;
914 (*callbackops->devmap_unmap)(dhp, dhp->dh_pvtp,
915 off, mlen, (devmap_cookie_t *)dhp,
916 &dhp->dh_pvtp, NULL, NULL);
918 dhp->dh_len = addr - dhp->dh_uvaddr;
919 dhpp = dhp->dh_next;
920 dhp->dh_next = NULL;
921 dhp = dhpp;
922 nsdp->devmap_data = dhp;
923 } else if ((addr + len) >= (dhp->dh_uvaddr + dhp->dh_len)) {
925 * dhp is enclosed by <addr, addr+len>.
927 dhp->dh_seg = nseg;
928 nsdp->devmap_data = dhp;
929 dhp = devmap_handle_unmap(dhp);
930 nsdp->devmap_data = dhp; /* XX redundant? */
931 } else if (((addr + len) > dhp->dh_uvaddr) &&
932 ((addr + len) < (dhp->dh_uvaddr + dhp->dh_len))) {
933 mlen = addr + len - dhp->dh_uvaddr;
935 (*callbackops->devmap_unmap)(dhp, dhp->dh_pvtp,
936 dhp->dh_uoff, mlen, NULL,
937 NULL, dhp, &dhp->dh_pvtp);
938 devmap_handle_reduce_len(dhp, mlen);
939 nsdp->devmap_data = dhp;
940 dhp->dh_seg = nseg;
941 dhp = dhp->dh_next;
943 dhp->dh_seg = nseg;
944 dhp = dhp->dh_next;
957 devmap_handle_reduce_len(devmap_handle_t *dhp, size_t len)
964 ASSERT(len < dhp->dh_len);
969 dhp->dh_len -= len;
970 dhp->dh_uoff += (offset_t)len;
971 dhp->dh_roff += (offset_t)len;
972 dhp->dh_uvaddr += len;
973 /* Need to grab dhp lock if REMAP */
974 HOLD_DHP_LOCK(dhp);
975 cp = dhp->dh_cookie;
976 if (!(dhp->dh_flags & DEVMAP_MAPPING_INVALID)) {
978 dhp->dh_pfn += btop(len);
980 pcp = (struct devmap_pmem_cookie *)dhp->dh_pcookie;
981 ASSERT((dhp->dh_roff & PAGEOFFSET) == 0 &&
982 dhp->dh_roff < ptob(pcp->dp_npages));
984 ASSERT(dhp->dh_roff < cp->size);
985 ASSERT(dhp->dh_cvaddr >= cp->cvaddr &&
986 dhp->dh_cvaddr < (cp->cvaddr + cp->size));
987 ASSERT((dhp->dh_cvaddr + len) <=
990 dhp->dh_cvaddr += len;
994 RELE_DHP_LOCK(dhp);
998 * Free devmap handle, dhp.
1002 devmap_handle_unmap(devmap_handle_t *dhp)
1004 struct devmap_callback_ctl *callbackops = &dhp->dh_callbackops;
1005 struct segdev_data *sdp = (struct segdev_data *)dhp->dh_seg->s_data;
1008 ASSERT(dhp != NULL);
1011 * before we free up dhp, call the driver's devmap_unmap entry point
1012 * to free resources allocated for this dhp.
1015 (*callbackops->devmap_unmap)(dhp, dhp->dh_pvtp, dhp->dh_uoff,
1016 dhp->dh_len, NULL, NULL, NULL, NULL);
1019 if (dhpp == dhp) { /* releasing first dhp, change sdp data */
1020 sdp->devmap_data = dhp->dh_next;
1022 while (dhpp->dh_next != dhp) {
1025 dhpp->dh_next = dhp->dh_next;
1027 dhpp = dhp->dh_next; /* return value is next dhp in chain */
1029 if (dhp->dh_softlock != NULL)
1030 devmap_softlock_rele(dhp);
1032 if (dhp->dh_ctx != NULL)
1033 devmap_ctx_rele(dhp);
1035 if (dhp->dh_flags & DEVMAP_LOCK_INITED) {
1036 mutex_destroy(&dhp->dh_lock);
1038 kmem_free(dhp, sizeof (devmap_handle_t));
1044 * Free complete devmap handles from dhp for len bytes
1045 * dhp can be either the first handle or a subsequent handle
1048 devmap_handle_unmap_head(devmap_handle_t *dhp, size_t len)
1055 while (len >= dhp->dh_len) {
1056 len -= dhp->dh_len;
1057 dhp = devmap_handle_unmap(dhp);
1059 if (len != 0) { /* partial unmap at head of first remaining dhp */
1060 callbackops = &dhp->dh_callbackops;
1067 (*callbackops->devmap_unmap)(dhp, dhp->dh_pvtp,
1068 dhp->dh_uoff, len, NULL, NULL, dhp, &dhp->dh_pvtp);
1069 devmap_handle_reduce_len(dhp, len);
1075 * RFE: Simpler to pass in dhp pointing at correct dhp (avoid find again)
1079 devmap_handle_unmap_tail(devmap_handle_t *dhp, caddr_t addr)
1081 register struct seg *seg = dhp->dh_seg;
1090 maplen = (size_t)(addr - dhp->dh_uvaddr);
1126 devmap_handle_t *dhp = (devmap_handle_t *)sdp->devmap_data;
1129 "segdev_free: dhp=%p seg=%p", (void *)dhp, (void *)seg);
1130 DEBUGF(3, (CE_CONT, "segdev_free: dhp %p seg %p\n",
1131 (void *)dhp, (void *)seg));
1139 while (dhp != NULL)
1140 dhp = devmap_handle_unmap(dhp);
1151 free_devmap_handle(devmap_handle_t *dhp)
1158 while (dhp != NULL) {
1159 dhpp = dhp->dh_next;
1160 if (dhp->dh_flags & DEVMAP_LOCK_INITED) {
1161 mutex_destroy(&dhp->dh_lock);
1164 if (dhp->dh_softlock != NULL)
1165 devmap_softlock_rele(dhp);
1167 if (dhp->dh_ctx != NULL)
1168 devmap_ctx_rele(dhp);
1170 kmem_free(dhp, sizeof (devmap_handle_t));
1171 dhp = dhpp;
1333 DEBUGF(3, (CE_CONT, "segdev_softunlock: dhp %p lockcnt %lx "
1340 devmap_handle_t *dhp;
1345 dhp = devmap_find_handle(dhp_head, addr);
1346 ASSERT(dhp != NULL);
1348 off = (ulong_t)(addr - dhp->dh_uvaddr);
1350 mlen = MIN(tlen, (dhp->dh_len - off));
1355 if (dhp_is_kpmem(dhp)) {
1357 (struct ddi_umem_cookie *)dhp->dh_cookie,
1364 if (dhp->dh_callbackops.devmap_access != NULL) {
1365 devmap_softlock_exit(dhp->dh_softlock,
1370 dhp = dhp->dh_next;
1413 devmap_handle_t *dhp) /* devmap handle if any for this page */
1423 "segdev_faultpage: dhp=%p seg=%p addr=%p", dhp, seg, addr);
1424 DEBUGF(8, (CE_CONT, "segdev_faultpage: dhp %p seg %p addr %p \n",
1425 (void *)dhp, (void *)seg, (void *)addr));
1468 * pfnum from dhp->dh_pfn (at beginning of segment) and offset from
1471 if (dhp == NULL) {
1472 /* If segment has devmap_data, then dhp should be non-NULL */
1482 /* ensure the dhp passed in contains addr. */
1483 ASSERT(dhp == devmap_find_handle(
1486 off = addr - dhp->dh_uvaddr;
1490 * fields in dhp used below are unchanged due to remap during
1493 cp = dhp->dh_cookie;
1494 if (dhp->dh_flags & DEVMAP_MAPPING_INVALID) {
1497 pfnum = dhp->dh_pfn + btop(off);
1499 pcp = (struct devmap_pmem_cookie *)dhp->dh_pcookie;
1500 ASSERT((dhp->dh_roff & PAGEOFFSET) == 0 &&
1501 dhp->dh_roff < ptob(pcp->dp_npages));
1503 pcp->dp_pparray[btop(off + dhp->dh_roff)]);
1505 ASSERT(dhp->dh_roff < cp->size);
1506 ASSERT(dhp->dh_cvaddr >= cp->cvaddr &&
1507 dhp->dh_cvaddr < (cp->cvaddr + cp->size));
1508 ASSERT((dhp->dh_cvaddr + off) <=
1510 ASSERT((dhp->dh_cvaddr + off + PAGESIZE) <=
1516 ASSERT((dhp->dh_roff &
1520 dhp->dh_roff)]);
1537 dhp->dh_cvaddr + off);
1544 prot |= dhp->dh_hat_attr;
1557 if (pf_is_memory(pfnum) || (dhp != NULL)) {
1604 devmap_handle_t *dhp;
1626 if ((dhp = devmap_find_handle(dhp_head, addr)) == NULL)
1654 * Loop through dhp list calling devmap_access or segdev_faultpages for
1698 devmap_handle_t *dhpp = dhp;
1758 * use the same device instance, the second dhp's LOCK call
1764 * and supported multi-dhp mappings with dissimilar devices
1773 /* calculate the offset corresponds to 'addr' in the first dhp. */
1774 off = (ulong_t)(addr - dhp->dh_uvaddr);
1787 * from addr to the end of mapping defined by dhp.
1789 mlen = MIN(len, (dhp->dh_len - off));
1791 HOLD_DHP_LOCK(dhp);
1797 (dhp->dh_flags & DEVMAP_FLAG_LARGE)) {
1798 devmap_get_large_pgsize(dhp, mlen, maddr,
1806 if (dhp->dh_callbackops.devmap_access != NULL) {
1818 RELE_DHP_LOCK(dhp);
1820 err = (*dhp->dh_callbackops.devmap_access)(
1821 dhp, (void *)dhp->dh_pvtp, aoff, llen, type, rw);
1828 type, rw, dhp);
1830 RELE_DHP_LOCK(dhp);
1836 * If not first dhp, use
1875 dhp = dhp->dh_next;
1878 ASSERT(!dhp || len == 0 || maddr == dhp->dh_uvaddr);
1894 * in dhp used below are not changed due to remap during this call.
1906 devmap_handle_t *dhp) /* devmap handle */
1915 "segdev_faultpages: dhp=%p seg=%p addr=%p len=%lx",
1916 (void *)dhp, (void *)seg, (void *)addr, len);
1918 "dhp %p seg %p addr %p len %lx\n",
1919 (void *)dhp, (void *)seg, (void *)addr, len));
1944 if ((dhp != NULL) && dhp_is_kpmem(dhp)) {
1945 kpmem_cookie = (struct ddi_umem_cookie *)dhp->dh_cookie;
1986 * - devmap framework (dhp is not NULL),
1990 if ((sdp->pageprot == 0) && (dhp != NULL) && dhp_is_devmem(dhp)) {
1994 if (dhp->dh_flags & DEVMAP_MAPPING_INVALID) {
2006 pfnum = dhp->dh_pfn + btop((uintptr_t)(addr - dhp->dh_uvaddr));
2009 hat_devload(hat, addr, len, pfnum, sdp->prot | dhp->dh_hat_attr,
2024 if (err = segdev_faultpage(hat, seg, a, vpage, type, rw, dhp)) {
2068 register devmap_handle_t *dhp;
2092 if ((dhp = devmap_find_handle(dhp_head, addr)) == NULL)
2098 off = (ulong_t)(addr - dhp->dh_uvaddr);
2100 while (dhp) {
2101 if ((dhp->dh_maxprot & prot) != prot)
2104 if (mlen > (dhp->dh_len - off)) {
2105 mlen -= dhp->dh_len - off;
2106 dhp = dhp->dh_next;
2151 dhp = tdhp = devmap_find_handle(dhp_head, addr);
2163 soff = (ulong_t)(addr - dhp->dh_uvaddr);
2165 mlen = MIN(slen, (dhp->dh_len - soff));
2166 hat_unload(seg->s_as->a_hat, dhp->dh_uvaddr,
2167 dhp->dh_len, HAT_UNLOAD);
2168 dhp = dhp->dh_next;
2496 devmap_device(devmap_handle_t *dhp, struct as *as, caddr_t *addr,
2508 "devmap_device:start dhp=%p addr=%p off=%llx, len=%lx",
2509 (void *)dhp, (void *)addr, off, len);
2511 DEBUGF(2, (CE_CONT, "devmap_device: dhp %p addr %p off %llx len %lx\n",
2512 (void *)dhp, (void *)addr, off, len));
2518 rdhp = maxdhp = dhp;
2523 maxprot |= dhp->dh_maxprot;
2525 offset = maxdhp->dh_uoff - dhp->dh_uoff;
2528 * Use the dhp that has the
2567 dev_a.dev = dhp->dh_dev;
2574 dev_a.prot = dhp->dh_prot;
2576 * devmap uses dhp->dh_hat_attr for hat.
2580 dev_a.devmap_data = (void *)dhp;
2592 register devmap_handle_t *dhp = (devmap_handle_t *)dhc;
2602 "devmap_do_ctxmgt:start dhp=%p off=%llx, len=%lx",
2603 (void *)dhp, off, len);
2604 DEBUGF(7, (CE_CONT, "devmap_do_ctxmgt: dhp %p off %llx len %lx\n",
2605 (void *)dhp, off, len));
2610 devctx = dhp->dh_ctx;
2623 if ((dhp->dh_timeout_length > 0) && (ncpus > 1)) {
2625 "devmap_do_ctxmgt:doing hysteresis, devctl %p dhp %p",
2626 devctx, dhp);
2639 ret = (*ctxmgt)(dhp, dhp->dh_pvtp, off, len, type, rw);
2650 "devmap_do_ctxmgt: ret=%x dhp=%p devctx=%p",
2651 ret, dhp, devctx);
2652 DEBUGF(1, (CE_CONT, "devmap_do_ctxmgt: ret %x dhp %p\n",
2653 ret, (void *)dhp));
2668 if (dhp->dh_timeout_length > 0) {
2672 devctx, dhp->dh_timeout_length);
2703 devmap_roundup(devmap_handle_t *dhp, ulong_t offset, size_t len,
2714 "devmap_roundup:start dhp=%p off=%lx len=%lx",
2715 (void *)dhp, offset, len);
2716 DEBUGF(2, (CE_CONT, "devmap_roundup: dhp %p off %lx len %lx\n",
2717 (void *)dhp, offset, len));
2727 base = (ulong_t)ptob(dhp->dh_pfn);
2728 for (level = dhp->dh_mmulevel; level >= 0; level--) {
2731 uvaddr = dhp->dh_uvaddr + (poff - base);
2733 ((poff + pg) <= (base + dhp->dh_len)) &&
2739 "devmap_roundup: base=%lx poff=%lx dhp=%p",
2740 base, poff, dhp);
2742 base, poff, dhp->dh_pfn));
2748 *opfn = dhp->dh_pfn + btop(poff - base);
2755 "devmap_roundup:ret dhp=%p level=%x rlen=%lx psiz=%p opfn=%p",
2756 (void *)dhp, level, rlen, pagesize, opfn);
2757 DEBUGF(1, (CE_CONT, "devmap_roundup: dhp %p "
2759 (void *)dhp, level, rlen, *pagesize, *opfn));
2765 * find the dhp that contains addr.
2770 devmap_handle_t *dhp;
2775 dhp = dhp_head;
2776 while (dhp) {
2777 if (addr >= dhp->dh_uvaddr &&
2778 addr < (dhp->dh_uvaddr + dhp->dh_len))
2779 return (dhp);
2780 dhp = dhp->dh_next;
2795 register devmap_handle_t *dhp = (devmap_handle_t *)dhc;
2801 "devmap_unload:start dhp=%p offset=%llx len=%lx",
2802 (void *)dhp, offset, len);
2803 DEBUGF(7, (CE_CONT, "devmap_unload: dhp %p offset %llx len %lx\n",
2804 (void *)dhp, offset, len));
2806 soff = (ssize_t)(offset - dhp->dh_uoff);
2808 if (soff < 0 || soff >= dhp->dh_len)
2824 size = dhp->dh_len - soff;
2827 if ((soff + size) > dhp->dh_len)
2833 * the dhp.
2835 addr = (caddr_t)(soff + dhp->dh_uvaddr);
2841 if (dhp->dh_flags & DEVMAP_FLAG_LARGE) {
2842 hat_unload(dhp->dh_seg->s_as->a_hat, dhp->dh_uvaddr,
2843 dhp->dh_len, HAT_UNLOAD|HAT_UNLOAD_OTHER);
2845 hat_unload(dhp->dh_seg->s_as->a_hat, addr, size,
2856 devmap_get_large_pgsize(devmap_handle_t *dhp, size_t len, caddr_t addr,
2872 ASSERT(dhp_is_devmem(dhp));
2873 ASSERT(!(dhp->dh_flags & DEVMAP_MAPPING_INVALID));
2876 off = (ulong_t)(addr - dhp->dh_uvaddr);
2883 len = devmap_roundup(dhp, off, len, &pfn, &pgsize);
2886 *laddr = dhp->dh_uvaddr + ptob(pfn - dhp->dh_pfn);
2891 off = ptob(pfn - dhp->dh_pfn) + pgsize;
2941 devmap_softlock_rele(devmap_handle_t *dhp)
2943 struct devmap_softlock *slock = dhp->dh_softlock;
2992 devmap_ctx_rele(devmap_handle_t *dhp)
2994 struct devmap_ctx *devctx = dhp->dh_ctx;
3063 devmap_handle_t *dhp = (devmap_handle_t *)dhc;
3064 struct as *asp = dhp->dh_seg->s_as;
3071 "devmap_load:start dhp=%p offset=%llx len=%lx",
3072 (void *)dhp, offset, len);
3074 DEBUGF(7, (CE_CONT, "devmap_load: dhp %p offset %llx len %lx\n",
3075 (void *)dhp, offset, len));
3085 soff = (ssize_t)(offset - dhp->dh_uoff);
3087 if (soff < 0 || soff >= dhp->dh_len)
3103 size = dhp->dh_len - soff;
3106 if ((soff + size) > dhp->dh_len)
3114 addr = (caddr_t)(soff + dhp->dh_uvaddr);
3116 HOLD_DHP_LOCK(dhp);
3118 dhp->dh_seg, addr, size, type, rw, dhp);
3119 RELE_DHP_LOCK(dhp);
3127 register devmap_handle_t *dhp;
3177 dhp = kmem_zalloc(sizeof (devmap_handle_t), KM_SLEEP);
3180 dhp_prev->dh_next = dhp;
3182 dhp_head = dhp;
3183 dhp_prev = dhp;
3185 dhp->dh_prot = prot;
3186 dhp->dh_orig_maxprot = dhp->dh_maxprot = maxprot;
3187 dhp->dh_dev = dev;
3188 dhp->dh_timeout_length = CTX_TIMEOUT_VALUE;
3189 dhp->dh_uoff = map_off;
3197 if ((ret = cdev_devmap(dev, dhp, map_off,
3208 callbackops = &dhp->dh_callbackops;
3226 dhp->dh_softlock = devmap_softlock_init(dev,
3228 dhp->dh_ctx = devmap_ctxinit(dev,
3233 * dh_softlock in a multi-dhp mapping
3241 slock = dhp->dh_softlock;
3242 if (slock != dhp->dh_softlock) {
3270 dhp = dhp_head;
3273 while (dhp != NULL) {
3274 callbackops = &dhp->dh_callbackops;
3275 dhp->dh_uvaddr = addr;
3276 dhp_curr = dhp;
3278 ret = (*callbackops->devmap_map)((devmap_cookie_t)dhp,
3280 dhp->dh_len, &dhp->dh_pvtp);
3288 dhp = dhp_head;
3290 while (dhp != dhp_curr) {
3291 callbackops = &dhp->dh_callbackops;
3294 dhp, dhp->dh_pvtp,
3295 map_off, dhp->dh_len,
3298 map_off += dhp->dh_len;
3299 dhp = dhp->dh_next;
3307 map_off += dhp->dh_len;
3308 addr += dhp->dh_len;
3309 dhp = dhp->dh_next;
3333 devmap_devmem_large_page_setup(devmap_handle_t *dhp)
3335 ASSERT(dhp_is_devmem(dhp));
3336 dhp->dh_mmulevel = 0;
3343 * 4. dhp length is at least as big as the large pagesize
3347 !(dhp->dh_flags & (DEVMAP_USE_PAGESIZE | DEVMAP_MAPPING_INVALID))) {
3351 base = (ulong_t)ptob(dhp->dh_pfn);
3354 if ((dhp->dh_len < pgsize) ||
3355 (!VA_PA_PGSIZE_ALIGNED((uintptr_t)dhp->dh_uvaddr,
3360 dhp->dh_mmulevel = level - 1;
3362 if (dhp->dh_mmulevel > 0) {
3363 dhp->dh_flags |= DEVMAP_FLAG_LARGE;
3365 dhp->dh_flags &= ~DEVMAP_FLAG_LARGE;
3378 devmap_handle_t *dhp = (devmap_handle_t *)dhc;
3385 "devmap_devmem_setup:start dhp=%p offset=%llx rnum=%d len=%lx",
3386 (void *)dhp, roff, rnumber, (uint_t)len);
3387 DEBUGF(2, (CE_CONT, "devmap_devmem_setup: dhp %p offset %llx "
3388 "rnum %d len %lx\n", (void *)dhp, roff, rnumber, len));
3391 * First to check if this function has been called for this dhp.
3393 if (dhp->dh_flags & DEVMAP_SETUP_DONE)
3396 if ((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) != dhp->dh_prot)
3410 dhp->dh_pfn = PFN_INVALID;
3428 mr.map_prot = maxprot & dhp->dh_orig_maxprot;
3438 err = ddi_map(dip, &mr, roff, len, (caddr_t *)&dhp->dh_pfn);
3439 dhp->dh_hat_attr = hp->ah_hat_flags;
3446 ASSERT(!pf_is_memory(dhp->dh_pfn));
3449 dhp->dh_flags |= (flags & DEVMAP_SETUP_FLAGS);
3450 dhp->dh_len = ptob(btopr(len));
3452 dhp->dh_cookie = DEVMAP_DEVMEM_COOKIE;
3453 dhp->dh_roff = ptob(btop(roff));
3456 devmap_devmem_large_page_setup(dhp);
3457 dhp->dh_maxprot = maxprot & dhp->dh_orig_maxprot;
3458 ASSERT((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) == dhp->dh_prot);
3462 bcopy(callbackops, &dhp->dh_callbackops,
3469 if (dhp->dh_flags & DEVMAP_ALLOW_REMAP) {
3470 mutex_init(&dhp->dh_lock, NULL, MUTEX_DEFAULT, NULL);
3471 dhp->dh_flags |= DEVMAP_LOCK_INITED;
3474 dhp->dh_flags |= DEVMAP_SETUP_DONE;
3484 devmap_handle_t *dhp = (devmap_handle_t *)dhc;
3493 "devmap_devmem_setup:start dhp=%p offset=%llx rnum=%d len=%lx",
3494 (void *)dhp, roff, rnumber, (uint_t)len);
3495 DEBUGF(2, (CE_CONT, "devmap_devmem_remap: dhp %p offset %llx "
3496 "rnum %d len %lx\n", (void *)dhp, roff, rnumber, len));
3502 if ((dhp->dh_flags & DEVMAP_SETUP_DONE) == 0 ||
3503 (dhp->dh_flags & DEVMAP_ALLOW_REMAP) == 0)
3510 if ((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) != dhp->dh_prot)
3519 HOLD_DHP_LOCK(dhp);
3523 * Do this while holding the dhp lock so other faults dont reestablish
3526 hat_unload(dhp->dh_seg->s_as->a_hat, dhp->dh_uvaddr,
3527 dhp->dh_len, HAT_UNLOAD|HAT_UNLOAD_OTHER);
3530 dhp->dh_flags |= DEVMAP_MAPPING_INVALID;
3531 dhp->dh_pfn = PFN_INVALID;
3534 dhp->dh_flags &= ~DEVMAP_MAPPING_INVALID;
3547 mr.map_prot = maxprot & dhp->dh_orig_maxprot;
3561 RELE_DHP_LOCK(dhp);
3566 * not want to overwrite the existing dhp with wrong data.
3568 dhp->dh_pfn = pfn;
3569 dhp->dh_hat_attr = hat_flags;
3573 dhp->dh_flags &= ~DEVMAP_FLAG_LARGE;
3575 dhp->dh_cookie = DEVMAP_DEVMEM_COOKIE;
3576 dhp->dh_roff = ptob(btop(roff));
3579 devmap_devmem_large_page_setup(dhp);
3580 dhp->dh_maxprot = maxprot & dhp->dh_orig_maxprot;
3581 ASSERT((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) == dhp->dh_prot);
3583 RELE_DHP_LOCK(dhp);
3598 devmap_handle_t *dhp = (devmap_handle_t *)dhc;
3606 "devmap_umem_setup:start dhp=%p offset=%llx cookie=%p len=%lx",
3607 (void *)dhp, off, cookie, len);
3608 DEBUGF(2, (CE_CONT, "devmap_umem_setup: dhp %p offset %llx "
3609 "cookie %p len %lx\n", (void *)dhp, off, (void *)cookie, len));
3623 * First to check if this function has been called for this dhp.
3625 if (dhp->dh_flags & DEVMAP_SETUP_DONE)
3628 if ((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) != dhp->dh_prot)
3640 dhp->dh_cookie = cookie;
3641 dhp->dh_roff = ptob(btop(off));
3642 dhp->dh_cvaddr = cp->cvaddr + dhp->dh_roff;
3644 i_ddi_cacheattr_to_hatacc(flags, &dhp->dh_hat_attr);
3646 i_ddi_devacc_to_hatacc(accattrp, &dhp->dh_hat_attr);
3670 dhp->dh_flags |= (flags & DEVMAP_SETUP_FLAGS);
3672 dhp->dh_len = ptob(btopr(len));
3673 dhp->dh_maxprot = maxprot & dhp->dh_orig_maxprot;
3674 ASSERT((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) == dhp->dh_prot);
3677 bcopy(callbackops, &dhp->dh_callbackops,
3683 if (dhp->dh_flags & DEVMAP_ALLOW_REMAP) {
3684 mutex_init(&dhp->dh_lock, NULL, MUTEX_DEFAULT, NULL);
3685 dhp->dh_flags |= DEVMAP_LOCK_INITED;
3688 dhp->dh_flags |= DEVMAP_SETUP_DONE;
3698 devmap_handle_t *dhp = (devmap_handle_t *)dhc;
3702 "devmap_umem_remap:start dhp=%p offset=%llx cookie=%p len=%lx",
3703 (void *)dhp, off, cookie, len);
3704 DEBUGF(2, (CE_CONT, "devmap_umem_remap: dhp %p offset %llx "
3705 "cookie %p len %lx\n", (void *)dhp, off, (void *)cookie, len));
3715 if ((dhp->dh_flags & DEVMAP_SETUP_DONE) == 0 ||
3716 (dhp->dh_flags & DEVMAP_ALLOW_REMAP) == 0)
3727 if ((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) != dhp->dh_prot)
3734 HOLD_DHP_LOCK(dhp);
3737 * Do this while holding the dhp lock so other faults dont reestablish
3740 hat_unload(dhp->dh_seg->s_as->a_hat, dhp->dh_uvaddr,
3741 dhp->dh_len, HAT_UNLOAD|HAT_UNLOAD_OTHER);
3743 dhp->dh_cookie = cookie;
3744 dhp->dh_roff = ptob(btop(off));
3745 dhp->dh_cvaddr = cp->cvaddr + dhp->dh_roff;
3747 i_ddi_cacheattr_to_hatacc(flags, &dhp->dh_hat_attr);
3749 i_ddi_devacc_to_hatacc(accattrp, &dhp->dh_hat_attr);
3752 dhp->dh_flags &= ~DEVMAP_FLAG_LARGE;
3754 dhp->dh_maxprot = maxprot & dhp->dh_orig_maxprot;
3755 ASSERT((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) == dhp->dh_prot);
3756 RELE_DHP_LOCK(dhp);
3767 devmap_handle_t *dhp = (devmap_handle_t *)dhc;
3770 "devmap_set_ctx_timeout:start dhp=%p ticks=%x",
3771 (void *)dhp, ticks);
3772 dhp->dh_timeout_length = ticks;
3776 devmap_default_access(devmap_cookie_t dhp, void *pvtp, offset_t off,
3785 return (devmap_load(dhp, off, len, type, rw));