Lines Matching refs:domain
79 static boolean_t dvma_map(domain_t *domain, uint64_t sdvma,
188 domain_t *domain;
198 domain = NULL;
200 (void *)bdf, (void *)&domain) == 0) {
201 ASSERT(domain);
202 ASSERT(domain->dom_did > 0);
203 return (domain);
210 bdf_domain_insert(immu_devi_t *immu_devi, domain_t *domain)
221 (void) mod_hash_insert(bdf_domain_hash, (void *)bdf, (void *)domain);
776 domain_t *domain;
787 domain = immu_devi->imd_domain;
791 if (domain)
794 return (domain);
814 ddi_err(DER_WARN, rdip, "device domain-id alloc error"
815 " domain-device: %s%d. immu unit is %s. Using "
816 "unity domain with domain-id (%d)",
829 domain_t *domain;
868 * In order to be a domain-dim, it must be a PCI device i.e.
886 domain = immu_devi->imd_domain;
890 if (domain && ddip) {
891 /* if domain is set, it must be the same */
893 ASSERT(domain == dvp->dva_domain);
895 dvp->dva_domain = domain;
905 /* domain is not set in either immu_devi or dvp */
906 domain = bdf_domain_lookup(immu_devi);
907 if (domain == NULL) {
911 /* ok, the BDF hash had a domain for this BDF. */
916 dvp->dva_domain = domain;
918 dvp->dva_domain = domain;
930 map_unity_domain(domain_t *domain)
950 (void) dvma_map(domain, 0, 1, dcookies, dcount, NULL,
969 (void) dvma_map(domain, start, npages, dcookies,
972 ddi_err(DER_LOG, domain->dom_dip, "iommu: mapping PHYS span [0x%" PRIx64
977 ddi_err(DER_LOG, domain->dom_dip,
987 (void) dvma_map(domain, start, npages,
994 ddi_err(DER_LOG, domain->dom_dip,
1004 (void) dvma_map(domain, start, npages,
1015 * Create the dvma arena for a domain with translation
1019 create_xlate_arena(immu_t *immu, domain_t *domain,
1031 arena_name = domain->dom_dvma_arena_name;
1035 sizeof (domain->dom_dvma_arena_name),
1036 "%s-domain-%d-xlate-DVMA-arena", immu->immu_name,
1037 domain->dom_did);
1072 domain->dom_dvma_arena = vmem_create(arena_name,
1082 if (domain->dom_dvma_arena == NULL) {
1085 "for domain ID (%d)", arena_name, domain->dom_did);
1107 vmem_ret = vmem_add(domain->dom_dvma_arena,
1113 "for domain ID (%d)",
1114 arena_name, domain->dom_did);
1125 * Set the domain and domain-dip for a dip
1131 domain_t *domain)
1150 ASSERT(fdomain == domain);
1152 immu_devi->imd_domain = domain;
1159 * Get domain for a device. The domain may be global in which case it
1162 * domains. Alternatively, the domain may be local to a IOMMU unit.
1166 * which the domain
1168 * immu_devi a domain may be either UNITY or translation (XLATE) domain.
1173 dev_info_t *ddip; /* topmost dip in domain i.e. domain owner */
1175 domain_t *domain;
1182 * Check if the domain is already set. This is usually true
1186 domain = immu_devi_domain(rdip, &ddip);
1187 if (domain) {
1189 return (domain);
1222 domain = dvarg.dva_domain; /* may be NULL */
1225 * We may find the domain during our ancestor walk on any one of our
1226 * ancestor dips, If the domain is found then the domain-dip
1228 * The domain-dip is the highest ancestor dip which shares the
1229 * same domain with edip.
1230 * The domain may or may not be found, but the domain dip must
1234 ddi_err(DER_MODE, rdip, "Cannot find domain dip for device.");
1239 * Did we find a domain ?
1241 if (domain) {
1246 domain = domain_create(immu, ddip, rdip, immu_flags);
1247 if (domain == NULL) {
1254 * We know *domain *is* the right domain, so panic if
1255 * another domain is set for either the request-dip or
1258 set_domain(ddip, ddip, domain);
1259 set_domain(rdip, ddip, domain);
1262 return (domain);
1268 domain_t *domain;
1270 /* domain created during boot and always use sleep flag */
1271 domain = kmem_zalloc(sizeof (domain_t), KM_SLEEP);
1273 rw_init(&(domain->dom_pgtable_rwlock), NULL, RW_DEFAULT, NULL);
1275 domain->dom_did = IMMU_UNITY_DID;
1276 domain->dom_maptype = IMMU_MAPTYPE_UNITY;
1278 domain->dom_immu = immu;
1279 immu->immu_unity_domain = domain;
1282 * Setup the domain's initial page table
1285 domain->dom_pgtable_root = pgtable_alloc(immu, IMMU_FLAGS_SLEEP);
1286 pgtable_zero(domain->dom_pgtable_root);
1289 * Only map all physical memory in to the unity domain
1294 map_unity_domain(domain);
1298 * put it on the system-wide UNITY domain list
1301 list_insert_tail(&immu_unity_domain_list, domain);
1306 * ddip is the domain-dip - the topmost dip in a domain
1309 * if domain is a non-shared domain rdip == ddip
1316 domain_t *domain;
1328 * of domains the unity domain will be allocated.
1332 /* domain overflow */
1338 domain = kmem_zalloc(sizeof (domain_t), kmflags);
1339 if (domain == NULL) {
1340 ddi_err(DER_PANIC, rdip, "Failed to alloc DVMA domain "
1345 rw_init(&(domain->dom_pgtable_rwlock), NULL, RW_DEFAULT, NULL);
1348 "immu%s-domain%d-pava-hash", immu->immu_name, did);
1350 domain->dom_did = did;
1351 domain->dom_immu = immu;
1352 domain->dom_maptype = IMMU_MAPTYPE_XLATE;
1353 domain->dom_dip = ddip;
1356 * Create xlate DVMA arena for this domain.
1358 create_xlate_arena(immu, domain, rdip, immu_flags);
1361 * Setup the domain's initial page table
1363 domain->dom_pgtable_root = pgtable_alloc(immu, immu_flags);
1364 if (domain->dom_pgtable_root == NULL) {
1366 "pgtable for domain (%d). IOMMU unit: %s",
1367 domain->dom_did, immu->immu_name);
1370 pgtable_zero(domain->dom_pgtable_root);
1373 * Since this is a immu unit-specific domain, put it on
1374 * the per-immu domain list.
1377 list_insert_head(&immu->immu_domain_list, domain);
1381 * Also put it on the system-wide xlate domain list
1384 list_insert_head(&immu_xlate_domain_list, domain);
1387 bdf_domain_insert(immu_devi, domain);
1396 (void) dvma_map(domain, 0, 1, dcookies, dcount, NULL,
1399 return (domain);
1407 * as the "uninitialized" domain - For devices not yet controlled
1409 * as the "unity" domain - For devices that will always belong
1410 * to the unity domain
1411 * as the "overflow" domain - Used for any new device after we
1413 * All of the above domains map into a single domain with
1415 * Each IMMU unity has its own unity/uninit/overflow domain
1449 context_set(immu_t *immu, domain_t *domain, pgtable_t *root_table,
1462 pgtable_root = domain->dom_pgtable_root;
1512 immu_flush_context_fsi(immu, 0, sid, domain->dom_did,
1516 CONT_SET_DID(hw_cent, domain->dom_did);
1519 if (domain->dom_did == IMMU_UNITY_DID &&
1629 immu_context_update(immu_t *immu, domain_t *domain, dev_info_t *ddip,
1643 ddi_err(DER_MODE, rdip, "immu_contexts_update: domain-dip or "
1677 context_set(immu, domain, immu->immu_ctx_root, r_bus,
1686 context_set(immu, domain, immu->immu_ctx_root, r_bus,
1696 context_set(immu, domain, immu->immu_ctx_root,
1699 context_set(immu, domain, immu->immu_ctx_root,
1709 context_set(immu, domain, immu->immu_ctx_root,
1718 context_set(immu, domain, immu->immu_ctx_root, d_bus,
1725 context_set(immu, domain, immu->immu_ctx_root, d_bus,
1846 PTE_clear_all(immu_t *immu, domain_t *domain, xlate_t *xlate,
1908 PDE_lookup(domain_t *domain, xlate_t *xlate, int nlevels)
1918 xlate->xlt_pgtable = domain->dom_pgtable_root;
1970 domain_t *domain;
1975 (void *)(uintptr_t)sid, (void *)&domain) != 0) {
1977 "no domain for faulting SID %08x", sid);
1981 immu = domain->dom_immu;
1984 vmem_walk(domain->dom_dvma_arena, VMEM_ALLOC, immu_fault_walk,
1987 ddi_err(DER_WARN, domain->dom_dip,
1993 if (!PDE_lookup(domain, xlate, nlevels)) {
1994 ddi_err(DER_WARN, domain->dom_dip,
1996 domain->dom_did, dvma);
2004 ddi_err(DER_WARN, domain->dom_dip,
2005 "domid %d pte: %" PRIx64 "(paddr %" PRIx64 ")", domain->dom_did,
2094 PTE_set_all(immu_t *immu, domain_t *domain, xlate_t *xlate,
2241 PDE_set_all(immu_t *immu, domain_t *domain, xlate_t *xlate, int nlevels,
2257 xlate->xlt_pgtable = domain->dom_pgtable_root;
2342 * domain: domain
2350 dvma_map(domain_t *domain, uint64_t sdvma, uint64_t snvpages,
2356 immu_t *immu = domain->dom_immu;
2368 if (PDE_set_all(immu, domain, xlate, nlevels, rdip, immu_flags)
2374 PTE_set_all(immu, domain, &xlate[1], &dvma, &n, dcookies,
2386 * domain: domain for requesting device
2387 * ddip: domain-dip
2393 dvma_unmap(domain_t *domain, uint64_t sdvma, uint64_t snpages,
2396 immu_t *immu = domain->dom_immu;
2410 if (!PDE_lookup(domain, xlate, nlevels))
2416 PTE_clear_all(immu, domain, &xlate[1], &dvma, &n, rdip);
2423 dvma_alloc(domain_t *domain, ddi_dma_attr_t *dma_attr, uint_t npages, int kmf)
2443 dvma = (uint64_t)(uintptr_t)vmem_xalloc(domain->dom_dvma_arena,
2461 domain_t *domain;
2464 domain = IMMU_DEVI(rdip)->imd_domain;
2465 immu = domain->dom_immu;
2479 dvma = (uint64_t)(uintptr_t)vmem_xalloc(domain->dom_dvma_arena,
2499 (void) PDE_set_all(immu, domain, xlate, nlevels, rdip,
2507 PTE_set_all(immu, domain, xlp, &dvma, &n, &immu_precookie,
2526 domain_t *domain;
2528 domain = IMMU_DEVI(rdip)->imd_domain;
2531 dvma_unmap(domain, ihp->ihp_predvma, IMMU_NPREPTES, rdip);
2532 vmem_free(domain->dom_dvma_arena,
2539 dvma_free(domain_t *domain, uint64_t dvma, uint64_t npages)
2543 if (domain->dom_maptype != IMMU_MAPTYPE_XLATE)
2546 vmem_free(domain->dom_dvma_arena, (void *)(uintptr_t)dvma, size);
2554 domain_t *domain;
2570 domain = IMMU_DEVI(rdip)->imd_domain;
2571 immu = domain->dom_immu;
2636 sdvma = dvma_alloc(domain, attrp, npgalloc,
2682 if (dvma_map(domain, dvma,
2710 if (dvma_map(domain, dvma, npages, dcookies,
2716 immu_flush_iotlb_psi(immu, domain->dom_did, sdvma, npgalloc,
2737 domain_t *domain;
2740 domain = IMMU_DEVI(rdip)->imd_domain;
2748 dvma_unmap(domain, dvma, npages, rdip);
2750 dvma_free(domain, dvma, npages);
2761 immu_regs_wbf_flush(domain->dom_immu);
2789 /* Setup BDF domain hash */
2827 * system increases, to expand domain DVMA
2837 domain_t *domain;
2846 domain = list_head(&immu_unity_domain_list);
2847 for (; domain; domain = list_next(&immu_unity_domain_list, domain)) {
2851 if (IMMU_ECAP_GET_PT(domain->dom_immu->immu_regs_excap))
2855 ddi_err(DER_LOG, domain->dom_dip,
2856 "iommu: unity-domain: Adding map "
2865 (void) dvma_map(domain, start, npages,
2877 domain_t *domain;
2917 * Setup DVMA domain for the device. This does
2922 domain = device_domain(rdip, &ddip, immu_flags);
2923 if (domain == NULL) {
2928 immu = domain->dom_immu;
2931 * If a domain is found, we must also have a domain dip
2933 * the same domain with rdip.
2935 if (domain->dom_did == 0 || ddip == NULL) {
2936 ddi_err(DER_MODE, rdip, "domain did 0(%d) or ddip NULL(%p)",
2937 domain->dom_did, ddip);
2942 set_domain(odip, ddip, domain);
2947 if (immu_context_update(immu, domain, ddip, rdip, immu_flags)
2962 domain_t *domain;
2968 domain = IMMU_DEVI(rdip)->imd_domain;
2969 immu = domain->dom_immu;
2971 pde_set = dvma_map(domain, mrng->mrng_start,
2977 immu_flush_iotlb_psi(immu, domain->dom_did, mrng->mrng_start,
3031 * IOMMU/domain again.