Lines Matching refs: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)))
245 static ulong_t devmap_roundup(devmap_handle_t *dhp, ulong_t offset, size_t len,
248 static void free_devmap_handle(devmap_handle_t *dhp);
250 static int devmap_handle_dup(devmap_handle_t *dhp, devmap_handle_t **new_dhp,
253 static devmap_handle_t *devmap_handle_unmap(devmap_handle_t *dhp);
255 static void devmap_handle_unmap_head(devmap_handle_t *dhp, size_t len);
257 static void devmap_handle_unmap_tail(devmap_handle_t *dhp, caddr_t addr);
259 static int devmap_device(devmap_handle_t *dhp, struct as *as, caddr_t *addr,
262 static void devmap_get_large_pgsize(devmap_handle_t *dhp, size_t len,
265 static void devmap_handle_reduce_len(devmap_handle_t *dhp, size_t len);
336 * within dhp->dh_timeout_length ticks
364 devmap_handle_t *dhp = (devmap_handle_t *)a->devmap_data;
387 sdp->devmap_data = dhp;
389 sdp->devmap_data = dhp = NULL;
410 while (dhp != NULL) {
411 dhp->dh_seg = seg;
412 dhp = dhp->dh_next;
420 * dhp specific maxprot because spec_addmap does not use maxprot.
463 devmap_handle_t *dhp = (devmap_handle_t *)sdp->devmap_data;
468 "segdev_dup:start dhp=%p, seg=%p", (void *)dhp, (void *)seg);
470 DEBUGF(3, (CE_CONT, "segdev_dup: dhp %p seg %p\n",
471 (void *)dhp, (void *)seg));
513 if (dhp != NULL) {
514 ret = devmap_handle_dup(dhp,
518 "segdev_dup:ret1 ret=%x, dhp=%p seg=%p",
519 ret, (void *)dhp, (void *)seg);
521 "segdev_dup: ret %x dhp %p seg %p\n",
522 ret, (void *)dhp, (void *)seg));
540 devmap_handle_dup(devmap_handle_t *dhp, devmap_handle_t **new_dhp,
547 while (dhp != NULL) {
550 /* Need to lock the original dhp while copying if REMAP */
551 HOLD_DHP_LOCK(dhp);
552 bcopy(dhp, newdhp, sizeof (devmap_handle_t));
553 RELE_DHP_LOCK(dhp);
564 if (dhp->dh_softlock != NULL)
568 if (dhp->dh_ctx != NULL)
587 ret = (*callbackops->devmap_dup)(dhp, dhp->dh_pvtp,
602 "newdhp %p dhp %p\n", (void *)newdhp,
603 (void *)dhp));
609 dhp = dhp->dh_next;
629 devmap_handle_t *dhp = (devmap_handle_t *)sdp->devmap_data;
639 "segdev_unmap:start dhp=%p, seg=%p addr=%p len=%lx",
640 (void *)dhp, (void *)seg, (void *)addr, len);
642 DEBUGF(3, (CE_CONT, "segdev_unmap: dhp %p seg %p addr %p len %lx\n",
643 (void *)dhp, (void *)seg, (void *)addr, len));
669 if (dhp != NULL) {
675 dhpp = tdhp = devmap_find_handle(dhp, addr);
682 if (tdhp != NULL) { /* found a dhp using large pages */
752 if (dhp != NULL)
753 devmap_handle_unmap_head(dhp, len);
784 if (dhp != NULL)
785 devmap_handle_unmap_tail(dhp, addr);
854 if (dhp == NULL) {
858 while (dhp != NULL) {
859 callbackops = &dhp->dh_callbackops;
861 "segdev_unmap: dhp=%p addr=%p", dhp, addr);
862 DEBUGF(3, (CE_CONT, "unmap: dhp %p addr %p uvaddr %p len %lx\n",
863 (void *)dhp, (void *)addr,
864 (void *)dhp->dh_uvaddr, dhp->dh_len));
866 if (addr == (dhp->dh_uvaddr + dhp->dh_len)) {
867 dhpp = dhp->dh_next;
868 dhp->dh_next = NULL;
869 dhp = dhpp;
870 } else if (addr > (dhp->dh_uvaddr + dhp->dh_len)) {
871 dhp = dhp->dh_next;
872 } else if (addr > dhp->dh_uvaddr &&
873 (addr + len) < (dhp->dh_uvaddr + dhp->dh_len)) {
875 * <addr, addr+len> is enclosed by dhp.
877 * ends at dhp->dh_uvaddr+dhp->dh_len.
880 HOLD_DHP_LOCK(dhp);
881 bcopy(dhp, newdhp, sizeof (devmap_handle_t));
882 RELE_DHP_LOCK(dhp);
884 newdhp->dh_next = dhp->dh_next;
885 if (dhp->dh_softlock != NULL)
889 if (dhp->dh_ctx != NULL)
897 (*callbackops->devmap_unmap)(dhp, dhp->dh_pvtp,
898 off, len, dhp, &dhp->dh_pvtp,
900 mlen = len + (addr - dhp->dh_uvaddr);
904 dhp->dh_len = addr - dhp->dh_uvaddr;
905 dhpp = dhp->dh_next;
906 dhp->dh_next = NULL;
907 dhp = dhpp;
908 } else if ((addr > dhp->dh_uvaddr) &&
909 ((addr + len) >= (dhp->dh_uvaddr + dhp->dh_len))) {
910 mlen = dhp->dh_len + dhp->dh_uvaddr - addr;
915 (*callbackops->devmap_unmap)(dhp, dhp->dh_pvtp,
916 off, mlen, (devmap_cookie_t *)dhp,
917 &dhp->dh_pvtp, NULL, NULL);
919 dhp->dh_len = addr - dhp->dh_uvaddr;
920 dhpp = dhp->dh_next;
921 dhp->dh_next = NULL;
922 dhp = dhpp;
923 nsdp->devmap_data = dhp;
924 } else if ((addr + len) >= (dhp->dh_uvaddr + dhp->dh_len)) {
926 * dhp is enclosed by <addr, addr+len>.
928 dhp->dh_seg = nseg;
929 nsdp->devmap_data = dhp;
930 dhp = devmap_handle_unmap(dhp);
931 nsdp->devmap_data = dhp; /* XX redundant? */
932 } else if (((addr + len) > dhp->dh_uvaddr) &&
933 ((addr + len) < (dhp->dh_uvaddr + dhp->dh_len))) {
934 mlen = addr + len - dhp->dh_uvaddr;
936 (*callbackops->devmap_unmap)(dhp, dhp->dh_pvtp,
937 dhp->dh_uoff, mlen, NULL,
938 NULL, dhp, &dhp->dh_pvtp);
939 devmap_handle_reduce_len(dhp, mlen);
940 nsdp->devmap_data = dhp;
941 dhp->dh_seg = nseg;
942 dhp = dhp->dh_next;
944 dhp->dh_seg = nseg;
945 dhp = dhp->dh_next;
958 devmap_handle_reduce_len(devmap_handle_t *dhp, size_t len)
965 ASSERT(len < dhp->dh_len);
970 dhp->dh_len -= len;
971 dhp->dh_uoff += (offset_t)len;
972 dhp->dh_roff += (offset_t)len;
973 dhp->dh_uvaddr += len;
974 /* Need to grab dhp lock if REMAP */
975 HOLD_DHP_LOCK(dhp);
976 cp = dhp->dh_cookie;
977 if (!(dhp->dh_flags & DEVMAP_MAPPING_INVALID)) {
979 dhp->dh_pfn += btop(len);
981 pcp = (struct devmap_pmem_cookie *)dhp->dh_pcookie;
982 ASSERT((dhp->dh_roff & PAGEOFFSET) == 0 &&
983 dhp->dh_roff < ptob(pcp->dp_npages));
985 ASSERT(dhp->dh_roff < cp->size);
986 ASSERT(dhp->dh_cvaddr >= cp->cvaddr &&
987 dhp->dh_cvaddr < (cp->cvaddr + cp->size));
988 ASSERT((dhp->dh_cvaddr + len) <=
991 dhp->dh_cvaddr += len;
995 RELE_DHP_LOCK(dhp);
999 * Free devmap handle, dhp.
1003 devmap_handle_unmap(devmap_handle_t *dhp)
1005 struct devmap_callback_ctl *callbackops = &dhp->dh_callbackops;
1006 struct segdev_data *sdp = (struct segdev_data *)dhp->dh_seg->s_data;
1009 ASSERT(dhp != NULL);
1012 * before we free up dhp, call the driver's devmap_unmap entry point
1013 * to free resources allocated for this dhp.
1016 (*callbackops->devmap_unmap)(dhp, dhp->dh_pvtp, dhp->dh_uoff,
1017 dhp->dh_len, NULL, NULL, NULL, NULL);
1020 if (dhpp == dhp) { /* releasing first dhp, change sdp data */
1021 sdp->devmap_data = dhp->dh_next;
1023 while (dhpp->dh_next != dhp) {
1026 dhpp->dh_next = dhp->dh_next;
1028 dhpp = dhp->dh_next; /* return value is next dhp in chain */
1030 if (dhp->dh_softlock != NULL)
1031 devmap_softlock_rele(dhp);
1033 if (dhp->dh_ctx != NULL)
1034 devmap_ctx_rele(dhp);
1036 if (dhp->dh_flags & DEVMAP_LOCK_INITED) {
1037 mutex_destroy(&dhp->dh_lock);
1039 kmem_free(dhp, sizeof (devmap_handle_t));
1045 * Free complete devmap handles from dhp for len bytes
1046 * dhp can be either the first handle or a subsequent handle
1049 devmap_handle_unmap_head(devmap_handle_t *dhp, size_t len)
1056 while (len >= dhp->dh_len) {
1057 len -= dhp->dh_len;
1058 dhp = devmap_handle_unmap(dhp);
1060 if (len != 0) { /* partial unmap at head of first remaining dhp */
1061 callbackops = &dhp->dh_callbackops;
1068 (*callbackops->devmap_unmap)(dhp, dhp->dh_pvtp,
1069 dhp->dh_uoff, len, NULL, NULL, dhp, &dhp->dh_pvtp);
1070 devmap_handle_reduce_len(dhp, len);
1076 * RFE: Simpler to pass in dhp pointing at correct dhp (avoid find again)
1080 devmap_handle_unmap_tail(devmap_handle_t *dhp, caddr_t addr)
1082 register struct seg *seg = dhp->dh_seg;
1091 maplen = (size_t)(addr - dhp->dh_uvaddr);
1127 devmap_handle_t *dhp = (devmap_handle_t *)sdp->devmap_data;
1130 "segdev_free: dhp=%p seg=%p", (void *)dhp, (void *)seg);
1131 DEBUGF(3, (CE_CONT, "segdev_free: dhp %p seg %p\n",
1132 (void *)dhp, (void *)seg));
1140 while (dhp != NULL)
1141 dhp = devmap_handle_unmap(dhp);
1152 free_devmap_handle(devmap_handle_t *dhp)
1159 while (dhp != NULL) {
1160 dhpp = dhp->dh_next;
1161 if (dhp->dh_flags & DEVMAP_LOCK_INITED) {
1162 mutex_destroy(&dhp->dh_lock);
1165 if (dhp->dh_softlock != NULL)
1166 devmap_softlock_rele(dhp);
1168 if (dhp->dh_ctx != NULL)
1169 devmap_ctx_rele(dhp);
1171 kmem_free(dhp, sizeof (devmap_handle_t));
1172 dhp = dhpp;
1334 DEBUGF(3, (CE_CONT, "segdev_softunlock: dhp %p lockcnt %lx "
1341 devmap_handle_t *dhp;
1346 dhp = devmap_find_handle(dhp_head, addr);
1347 ASSERT(dhp != NULL);
1349 off = (ulong_t)(addr - dhp->dh_uvaddr);
1351 mlen = MIN(tlen, (dhp->dh_len - off));
1356 if (dhp_is_kpmem(dhp)) {
1358 (struct ddi_umem_cookie *)dhp->dh_cookie,
1365 if (dhp->dh_callbackops.devmap_access != NULL) {
1366 devmap_softlock_exit(dhp->dh_softlock,
1371 dhp = dhp->dh_next;
1414 devmap_handle_t *dhp) /* devmap handle if any for this page */
1424 "segdev_faultpage: dhp=%p seg=%p addr=%p", dhp, seg, addr);
1425 DEBUGF(8, (CE_CONT, "segdev_faultpage: dhp %p seg %p addr %p \n",
1426 (void *)dhp, (void *)seg, (void *)addr));
1469 * pfnum from dhp->dh_pfn (at beginning of segment) and offset from
1472 if (dhp == NULL) {
1473 /* If segment has devmap_data, then dhp should be non-NULL */
1483 /* ensure the dhp passed in contains addr. */
1484 ASSERT(dhp == devmap_find_handle(
1487 off = addr - dhp->dh_uvaddr;
1491 * fields in dhp used below are unchanged due to remap during
1494 cp = dhp->dh_cookie;
1495 if (dhp->dh_flags & DEVMAP_MAPPING_INVALID) {
1498 pfnum = dhp->dh_pfn + btop(off);
1500 pcp = (struct devmap_pmem_cookie *)dhp->dh_pcookie;
1501 ASSERT((dhp->dh_roff & PAGEOFFSET) == 0 &&
1502 dhp->dh_roff < ptob(pcp->dp_npages));
1504 pcp->dp_pparray[btop(off + dhp->dh_roff)]);
1506 ASSERT(dhp->dh_roff < cp->size);
1507 ASSERT(dhp->dh_cvaddr >= cp->cvaddr &&
1508 dhp->dh_cvaddr < (cp->cvaddr + cp->size));
1509 ASSERT((dhp->dh_cvaddr + off) <=
1511 ASSERT((dhp->dh_cvaddr + off + PAGESIZE) <=
1517 ASSERT((dhp->dh_roff &
1521 dhp->dh_roff)]);
1538 dhp->dh_cvaddr + off);
1545 prot |= dhp->dh_hat_attr;
1558 if (pf_is_memory(pfnum) || (dhp != NULL)) {
1605 devmap_handle_t *dhp;
1627 if ((dhp = devmap_find_handle(dhp_head, addr)) == NULL)
1655 * Loop through dhp list calling devmap_access or segdev_faultpages for
1699 devmap_handle_t *dhpp = dhp;
1759 * use the same device instance, the second dhp's LOCK call
1765 * and supported multi-dhp mappings with dissimilar devices
1774 /* calculate the offset corresponds to 'addr' in the first dhp. */
1775 off = (ulong_t)(addr - dhp->dh_uvaddr);
1788 * from addr to the end of mapping defined by dhp.
1790 mlen = MIN(len, (dhp->dh_len - off));
1792 HOLD_DHP_LOCK(dhp);
1798 (dhp->dh_flags & DEVMAP_FLAG_LARGE)) {
1799 devmap_get_large_pgsize(dhp, mlen, maddr,
1807 if (dhp->dh_callbackops.devmap_access != NULL) {
1819 RELE_DHP_LOCK(dhp);
1821 err = (*dhp->dh_callbackops.devmap_access)(
1822 dhp, (void *)dhp->dh_pvtp, aoff, llen, type, rw);
1829 type, rw, dhp);
1831 RELE_DHP_LOCK(dhp);
1837 * If not first dhp, use
1876 dhp = dhp->dh_next;
1879 ASSERT(!dhp || len == 0 || maddr == dhp->dh_uvaddr);
1895 * in dhp used below are not changed due to remap during this call.
1907 devmap_handle_t *dhp) /* devmap handle */
1916 "segdev_faultpages: dhp=%p seg=%p addr=%p len=%lx",
1917 (void *)dhp, (void *)seg, (void *)addr, len);
1919 "dhp %p seg %p addr %p len %lx\n",
1920 (void *)dhp, (void *)seg, (void *)addr, len));
1945 if ((dhp != NULL) && dhp_is_kpmem(dhp)) {
1946 kpmem_cookie = (struct ddi_umem_cookie *)dhp->dh_cookie;
1987 * - devmap framework (dhp is not NULL),
1991 if ((sdp->pageprot == 0) && (dhp != NULL) && dhp_is_devmem(dhp)) {
1995 if (dhp->dh_flags & DEVMAP_MAPPING_INVALID) {
2007 pfnum = dhp->dh_pfn + btop((uintptr_t)(addr - dhp->dh_uvaddr));
2010 hat_devload(hat, addr, len, pfnum, sdp->prot | dhp->dh_hat_attr,
2025 if (err = segdev_faultpage(hat, seg, a, vpage, type, rw, dhp)) {
2069 register devmap_handle_t *dhp;
2093 if ((dhp = devmap_find_handle(dhp_head, addr)) == NULL)
2099 off = (ulong_t)(addr - dhp->dh_uvaddr);
2101 while (dhp) {
2102 if ((dhp->dh_maxprot & prot) != prot)
2105 if (mlen > (dhp->dh_len - off)) {
2106 mlen -= dhp->dh_len - off;
2107 dhp = dhp->dh_next;
2152 dhp = tdhp = devmap_find_handle(dhp_head, addr);
2164 soff = (ulong_t)(addr - dhp->dh_uvaddr);
2166 mlen = MIN(slen, (dhp->dh_len - soff));
2167 hat_unload(seg->s_as->a_hat, dhp->dh_uvaddr,
2168 dhp->dh_len, HAT_UNLOAD);
2169 dhp = dhp->dh_next;
2497 devmap_device(devmap_handle_t *dhp, struct as *as, caddr_t *addr,
2509 "devmap_device:start dhp=%p addr=%p off=%llx, len=%lx",
2510 (void *)dhp, (void *)addr, off, len);
2512 DEBUGF(2, (CE_CONT, "devmap_device: dhp %p addr %p off %llx len %lx\n",
2513 (void *)dhp, (void *)addr, off, len));
2519 rdhp = maxdhp = dhp;
2524 maxprot |= dhp->dh_maxprot;
2526 offset = maxdhp->dh_uoff - dhp->dh_uoff;
2529 * Use the dhp that has the
2568 dev_a.dev = dhp->dh_dev;
2575 dev_a.prot = dhp->dh_prot;
2577 * devmap uses dhp->dh_hat_attr for hat.
2581 dev_a.devmap_data = (void *)dhp;
2593 register devmap_handle_t *dhp = (devmap_handle_t *)dhc;
2603 "devmap_do_ctxmgt:start dhp=%p off=%llx, len=%lx",
2604 (void *)dhp, off, len);
2605 DEBUGF(7, (CE_CONT, "devmap_do_ctxmgt: dhp %p off %llx len %lx\n",
2606 (void *)dhp, off, len));
2611 devctx = dhp->dh_ctx;
2624 if ((dhp->dh_timeout_length > 0) && (ncpus > 1)) {
2626 "devmap_do_ctxmgt:doing hysteresis, devctl %p dhp %p",
2627 devctx, dhp);
2640 ret = (*ctxmgt)(dhp, dhp->dh_pvtp, off, len, type, rw);
2651 "devmap_do_ctxmgt: ret=%x dhp=%p devctx=%p",
2652 ret, dhp, devctx);
2653 DEBUGF(1, (CE_CONT, "devmap_do_ctxmgt: ret %x dhp %p\n",
2654 ret, (void *)dhp));
2669 if (dhp->dh_timeout_length > 0) {
2673 devctx, dhp->dh_timeout_length);
2704 devmap_roundup(devmap_handle_t *dhp, ulong_t offset, size_t len,
2715 "devmap_roundup:start dhp=%p off=%lx len=%lx",
2716 (void *)dhp, offset, len);
2717 DEBUGF(2, (CE_CONT, "devmap_roundup: dhp %p off %lx len %lx\n",
2718 (void *)dhp, offset, len));
2728 base = (ulong_t)ptob(dhp->dh_pfn);
2729 for (level = dhp->dh_mmulevel; level >= 0; level--) {
2732 uvaddr = dhp->dh_uvaddr + (poff - base);
2734 ((poff + pg) <= (base + dhp->dh_len)) &&
2740 "devmap_roundup: base=%lx poff=%lx dhp=%p",
2741 base, poff, dhp);
2743 base, poff, dhp->dh_pfn));
2749 *opfn = dhp->dh_pfn + btop(poff - base);
2756 "devmap_roundup:ret dhp=%p level=%x rlen=%lx psiz=%p opfn=%p",
2757 (void *)dhp, level, rlen, pagesize, opfn);
2758 DEBUGF(1, (CE_CONT, "devmap_roundup: dhp %p "
2760 (void *)dhp, level, rlen, *pagesize, *opfn));
2766 * find the dhp that contains addr.
2771 devmap_handle_t *dhp;
2776 dhp = dhp_head;
2777 while (dhp) {
2778 if (addr >= dhp->dh_uvaddr &&
2779 addr < (dhp->dh_uvaddr + dhp->dh_len))
2780 return (dhp);
2781 dhp = dhp->dh_next;
2796 register devmap_handle_t *dhp = (devmap_handle_t *)dhc;
2802 "devmap_unload:start dhp=%p offset=%llx len=%lx",
2803 (void *)dhp, offset, len);
2804 DEBUGF(7, (CE_CONT, "devmap_unload: dhp %p offset %llx len %lx\n",
2805 (void *)dhp, offset, len));
2807 soff = (ssize_t)(offset - dhp->dh_uoff);
2809 if (soff < 0 || soff >= dhp->dh_len)
2825 size = dhp->dh_len - soff;
2828 if ((soff + size) > dhp->dh_len)
2834 * the dhp.
2836 addr = (caddr_t)(soff + dhp->dh_uvaddr);
2842 if (dhp->dh_flags & DEVMAP_FLAG_LARGE) {
2843 hat_unload(dhp->dh_seg->s_as->a_hat, dhp->dh_uvaddr,
2844 dhp->dh_len, HAT_UNLOAD|HAT_UNLOAD_OTHER);
2846 hat_unload(dhp->dh_seg->s_as->a_hat, addr, size,
2857 devmap_get_large_pgsize(devmap_handle_t *dhp, size_t len, caddr_t addr,
2873 ASSERT(dhp_is_devmem(dhp));
2874 ASSERT(!(dhp->dh_flags & DEVMAP_MAPPING_INVALID));
2877 off = (ulong_t)(addr - dhp->dh_uvaddr);
2884 len = devmap_roundup(dhp, off, len, &pfn, &pgsize);
2887 *laddr = dhp->dh_uvaddr + ptob(pfn - dhp->dh_pfn);
2892 off = ptob(pfn - dhp->dh_pfn) + pgsize;
2942 devmap_softlock_rele(devmap_handle_t *dhp)
2944 struct devmap_softlock *slock = dhp->dh_softlock;
2993 devmap_ctx_rele(devmap_handle_t *dhp)
2995 struct devmap_ctx *devctx = dhp->dh_ctx;
3064 devmap_handle_t *dhp = (devmap_handle_t *)dhc;
3065 struct as *asp = dhp->dh_seg->s_as;
3072 "devmap_load:start dhp=%p offset=%llx len=%lx",
3073 (void *)dhp, offset, len);
3075 DEBUGF(7, (CE_CONT, "devmap_load: dhp %p offset %llx len %lx\n",
3076 (void *)dhp, offset, len));
3086 soff = (ssize_t)(offset - dhp->dh_uoff);
3088 if (soff < 0 || soff >= dhp->dh_len)
3104 size = dhp->dh_len - soff;
3107 if ((soff + size) > dhp->dh_len)
3115 addr = (caddr_t)(soff + dhp->dh_uvaddr);
3117 HOLD_DHP_LOCK(dhp);
3119 dhp->dh_seg, addr, size, type, rw, dhp);
3120 RELE_DHP_LOCK(dhp);
3128 register devmap_handle_t *dhp;
3178 dhp = kmem_zalloc(sizeof (devmap_handle_t), KM_SLEEP);
3181 dhp_prev->dh_next = dhp;
3183 dhp_head = dhp;
3184 dhp_prev = dhp;
3186 dhp->dh_prot = prot;
3187 dhp->dh_orig_maxprot = dhp->dh_maxprot = maxprot;
3188 dhp->dh_dev = dev;
3189 dhp->dh_timeout_length = CTX_TIMEOUT_VALUE;
3190 dhp->dh_uoff = map_off;
3198 if ((ret = cdev_devmap(dev, dhp, map_off,
3209 callbackops = &dhp->dh_callbackops;
3227 dhp->dh_softlock = devmap_softlock_init(dev,
3229 dhp->dh_ctx = devmap_ctxinit(dev,
3234 * dh_softlock in a multi-dhp mapping
3242 slock = dhp->dh_softlock;
3243 if (slock != dhp->dh_softlock) {
3271 dhp = dhp_head;
3274 while (dhp != NULL) {
3275 callbackops = &dhp->dh_callbackops;
3276 dhp->dh_uvaddr = addr;
3277 dhp_curr = dhp;
3279 ret = (*callbackops->devmap_map)((devmap_cookie_t)dhp,
3281 dhp->dh_len, &dhp->dh_pvtp);
3289 dhp = dhp_head;
3291 while (dhp != dhp_curr) {
3292 callbackops = &dhp->dh_callbackops;
3295 dhp, dhp->dh_pvtp,
3296 map_off, dhp->dh_len,
3299 map_off += dhp->dh_len;
3300 dhp = dhp->dh_next;
3308 map_off += dhp->dh_len;
3309 addr += dhp->dh_len;
3310 dhp = dhp->dh_next;
3334 devmap_devmem_large_page_setup(devmap_handle_t *dhp)
3336 ASSERT(dhp_is_devmem(dhp));
3337 dhp->dh_mmulevel = 0;
3344 * 4. dhp length is at least as big as the large pagesize
3348 !(dhp->dh_flags & (DEVMAP_USE_PAGESIZE | DEVMAP_MAPPING_INVALID))) {
3352 base = (ulong_t)ptob(dhp->dh_pfn);
3355 if ((dhp->dh_len < pgsize) ||
3356 (!VA_PA_PGSIZE_ALIGNED((uintptr_t)dhp->dh_uvaddr,
3361 dhp->dh_mmulevel = level - 1;
3363 if (dhp->dh_mmulevel > 0) {
3364 dhp->dh_flags |= DEVMAP_FLAG_LARGE;
3366 dhp->dh_flags &= ~DEVMAP_FLAG_LARGE;
3379 devmap_handle_t *dhp = (devmap_handle_t *)dhc;
3386 "devmap_devmem_setup:start dhp=%p offset=%llx rnum=%d len=%lx",
3387 (void *)dhp, roff, rnumber, (uint_t)len);
3388 DEBUGF(2, (CE_CONT, "devmap_devmem_setup: dhp %p offset %llx "
3389 "rnum %d len %lx\n", (void *)dhp, roff, rnumber, len));
3392 * First to check if this function has been called for this dhp.
3394 if (dhp->dh_flags & DEVMAP_SETUP_DONE)
3397 if ((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) != dhp->dh_prot)
3411 dhp->dh_pfn = PFN_INVALID;
3429 mr.map_prot = maxprot & dhp->dh_orig_maxprot;
3439 err = ddi_map(dip, &mr, roff, len, (caddr_t *)&dhp->dh_pfn);
3440 dhp->dh_hat_attr = hp->ah_hat_flags;
3447 ASSERT(!pf_is_memory(dhp->dh_pfn));
3450 dhp->dh_flags |= (flags & DEVMAP_SETUP_FLAGS);
3451 dhp->dh_len = ptob(btopr(len));
3453 dhp->dh_cookie = DEVMAP_DEVMEM_COOKIE;
3454 dhp->dh_roff = ptob(btop(roff));
3457 devmap_devmem_large_page_setup(dhp);
3458 dhp->dh_maxprot = maxprot & dhp->dh_orig_maxprot;
3459 ASSERT((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) == dhp->dh_prot);
3463 bcopy(callbackops, &dhp->dh_callbackops,
3470 if (dhp->dh_flags & DEVMAP_ALLOW_REMAP) {
3471 mutex_init(&dhp->dh_lock, NULL, MUTEX_DEFAULT, NULL);
3472 dhp->dh_flags |= DEVMAP_LOCK_INITED;
3475 dhp->dh_flags |= DEVMAP_SETUP_DONE;
3485 devmap_handle_t *dhp = (devmap_handle_t *)dhc;
3494 "devmap_devmem_setup:start dhp=%p offset=%llx rnum=%d len=%lx",
3495 (void *)dhp, roff, rnumber, (uint_t)len);
3496 DEBUGF(2, (CE_CONT, "devmap_devmem_remap: dhp %p offset %llx "
3497 "rnum %d len %lx\n", (void *)dhp, roff, rnumber, len));
3503 if ((dhp->dh_flags & DEVMAP_SETUP_DONE) == 0 ||
3504 (dhp->dh_flags & DEVMAP_ALLOW_REMAP) == 0)
3511 if ((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) != dhp->dh_prot)
3520 HOLD_DHP_LOCK(dhp);
3524 * Do this while holding the dhp lock so other faults dont reestablish
3527 hat_unload(dhp->dh_seg->s_as->a_hat, dhp->dh_uvaddr,
3528 dhp->dh_len, HAT_UNLOAD|HAT_UNLOAD_OTHER);
3531 dhp->dh_flags |= DEVMAP_MAPPING_INVALID;
3532 dhp->dh_pfn = PFN_INVALID;
3535 dhp->dh_flags &= ~DEVMAP_MAPPING_INVALID;
3548 mr.map_prot = maxprot & dhp->dh_orig_maxprot;
3562 RELE_DHP_LOCK(dhp);
3567 * not want to overwrite the existing dhp with wrong data.
3569 dhp->dh_pfn = pfn;
3570 dhp->dh_hat_attr = hat_flags;
3574 dhp->dh_flags &= ~DEVMAP_FLAG_LARGE;
3576 dhp->dh_cookie = DEVMAP_DEVMEM_COOKIE;
3577 dhp->dh_roff = ptob(btop(roff));
3580 devmap_devmem_large_page_setup(dhp);
3581 dhp->dh_maxprot = maxprot & dhp->dh_orig_maxprot;
3582 ASSERT((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) == dhp->dh_prot);
3584 RELE_DHP_LOCK(dhp);
3599 devmap_handle_t *dhp = (devmap_handle_t *)dhc;
3607 "devmap_umem_setup:start dhp=%p offset=%llx cookie=%p len=%lx",
3608 (void *)dhp, off, cookie, len);
3609 DEBUGF(2, (CE_CONT, "devmap_umem_setup: dhp %p offset %llx "
3610 "cookie %p len %lx\n", (void *)dhp, off, (void *)cookie, len));
3624 * First to check if this function has been called for this dhp.
3626 if (dhp->dh_flags & DEVMAP_SETUP_DONE)
3629 if ((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) != dhp->dh_prot)
3641 dhp->dh_cookie = cookie;
3642 dhp->dh_roff = ptob(btop(off));
3643 dhp->dh_cvaddr = cp->cvaddr + dhp->dh_roff;
3645 i_ddi_cacheattr_to_hatacc(flags, &dhp->dh_hat_attr);
3647 i_ddi_devacc_to_hatacc(accattrp, &dhp->dh_hat_attr);
3671 dhp->dh_flags |= (flags & DEVMAP_SETUP_FLAGS);
3673 dhp->dh_len = ptob(btopr(len));
3674 dhp->dh_maxprot = maxprot & dhp->dh_orig_maxprot;
3675 ASSERT((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) == dhp->dh_prot);
3678 bcopy(callbackops, &dhp->dh_callbackops,
3684 if (dhp->dh_flags & DEVMAP_ALLOW_REMAP) {
3685 mutex_init(&dhp->dh_lock, NULL, MUTEX_DEFAULT, NULL);
3686 dhp->dh_flags |= DEVMAP_LOCK_INITED;
3689 dhp->dh_flags |= DEVMAP_SETUP_DONE;
3699 devmap_handle_t *dhp = (devmap_handle_t *)dhc;
3703 "devmap_umem_remap:start dhp=%p offset=%llx cookie=%p len=%lx",
3704 (void *)dhp, off, cookie, len);
3705 DEBUGF(2, (CE_CONT, "devmap_umem_remap: dhp %p offset %llx "
3706 "cookie %p len %lx\n", (void *)dhp, off, (void *)cookie, len));
3716 if ((dhp->dh_flags & DEVMAP_SETUP_DONE) == 0 ||
3717 (dhp->dh_flags & DEVMAP_ALLOW_REMAP) == 0)
3728 if ((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) != dhp->dh_prot)
3735 HOLD_DHP_LOCK(dhp);
3738 * Do this while holding the dhp lock so other faults dont reestablish
3741 hat_unload(dhp->dh_seg->s_as->a_hat, dhp->dh_uvaddr,
3742 dhp->dh_len, HAT_UNLOAD|HAT_UNLOAD_OTHER);
3744 dhp->dh_cookie = cookie;
3745 dhp->dh_roff = ptob(btop(off));
3746 dhp->dh_cvaddr = cp->cvaddr + dhp->dh_roff;
3748 i_ddi_cacheattr_to_hatacc(flags, &dhp->dh_hat_attr);
3750 i_ddi_devacc_to_hatacc(accattrp, &dhp->dh_hat_attr);
3753 dhp->dh_flags &= ~DEVMAP_FLAG_LARGE;
3755 dhp->dh_maxprot = maxprot & dhp->dh_orig_maxprot;
3756 ASSERT((dhp->dh_prot & dhp->dh_orig_maxprot & maxprot) == dhp->dh_prot);
3757 RELE_DHP_LOCK(dhp);
3768 devmap_handle_t *dhp = (devmap_handle_t *)dhc;
3771 "devmap_set_ctx_timeout:start dhp=%p ticks=%x",
3772 (void *)dhp, ticks);
3773 dhp->dh_timeout_length = ticks;
3777 devmap_default_access(devmap_cookie_t dhp, void *pvtp, offset_t off,
3786 return (devmap_load(dhp, off, len, type, rw));