geom = &dma_domain->iommu_domain.geometry;
 
-       if (!win_cnt || !dma_domain->geom_size) {
+       if (!win_cnt) {
                pr_debug("Number of windows/geometry not configured for the domain\n");
                return 0;
        }
                dma_addr_t subwin_iova;
                u32 wnd;
 
-               subwin_size = dma_domain->geom_size >> ilog2(win_cnt);
+               subwin_size = (geom->aperture_end + 1) >> ilog2(win_cnt);
                subwin_iova = iova & ~(subwin_size - 1);
                wnd = (subwin_iova - geom->aperture_start) >> ilog2(subwin_size);
                win_ptr = &dma_domain->win_arr[wnd];
        get_ome_index(&omi_index, dev);
 
        window_addr = geom_attr->aperture_start;
-       window_size = dma_domain->geom_size;
+       window_size = geom_attr->aperture_end + 1;
 
        spin_lock_irqsave(&iommu_lock, flags);
        ret = pamu_disable_liodn(liodn);
        domain->stash_id = ~(u32)0;
        domain->snoop_id = ~(u32)0;
        domain->win_cnt = pamu_get_max_subwin_cnt();
-       domain->geom_size = 0;
 
        INIT_LIST_HEAD(&domain->devices);
 
                return -EINVAL;
        }
 
-       win_size = dma_domain->geom_size >> ilog2(dma_domain->win_cnt);
+       win_size = (domain->geometry.aperture_end + 1) >>
+                       ilog2(dma_domain->win_cnt);
        if (size > win_size) {
                pr_debug("Invalid window size\n");
                spin_unlock_irqrestore(&dma_domain->domain_lock, flags);
                pr_debug("missing fsl,liodn property at %pOF\n", dev->of_node);
 }
 
-static  int configure_domain_geometry(struct iommu_domain *domain, void *data)
-{
-       struct iommu_domain_geometry *geom_attr = data;
-       struct fsl_dma_domain *dma_domain = to_fsl_dma_domain(domain);
-       dma_addr_t geom_size;
-       unsigned long flags;
-
-       geom_size = geom_attr->aperture_end - geom_attr->aperture_start + 1;
-       /*
-        * Sanity check the geometry size. Also, we do not support
-        * DMA outside of the geometry.
-        */
-       if (check_size(geom_size, geom_attr->aperture_start) ||
-           !geom_attr->force_aperture) {
-               pr_debug("Invalid PAMU geometry attributes\n");
-               return -EINVAL;
-       }
-
-       spin_lock_irqsave(&dma_domain->domain_lock, flags);
-       if (dma_domain->enabled) {
-               pr_debug("Can't set geometry attributes as domain is active\n");
-               spin_unlock_irqrestore(&dma_domain->domain_lock, flags);
-               return  -EBUSY;
-       }
-
-       /* Copy the domain geometry information */
-       memcpy(&domain->geometry, geom_attr,
-              sizeof(struct iommu_domain_geometry));
-       dma_domain->geom_size = geom_size;
-
-       spin_unlock_irqrestore(&dma_domain->domain_lock, flags);
-
-       return 0;
-}
-
 /* Set the domain stash attribute */
 static int configure_domain_stash(struct fsl_dma_domain *dma_domain, void *data)
 {
                return  -EBUSY;
        }
 
-       /* Ensure that the geometry has been set for the domain */
-       if (!dma_domain->geom_size) {
-               pr_debug("Please configure geometry before setting the number of windows\n");
-               spin_unlock_irqrestore(&dma_domain->domain_lock, flags);
-               return -EINVAL;
-       }
-
        /*
         * Ensure we have valid window count i.e. it should be less than
         * maximum permissible limit and should be a power of two.
        int ret = 0;
 
        switch (attr_type) {
-       case DOMAIN_ATTR_GEOMETRY:
-               ret = configure_domain_geometry(domain, data);
-               break;
        case DOMAIN_ATTR_FSL_PAMU_STASH:
                ret = configure_domain_stash(dma_domain, data);
                break;
 
 #ifdef CONFIG_FSL_PAMU
        struct device *dev = pcfg->dev;
        int window_count = 1;
-       struct iommu_domain_geometry geom_attr;
        struct pamu_stash_attribute stash_attr;
        int ret;
 
                dev_err(dev, "%s(): iommu_domain_alloc() failed", __func__);
                goto no_iommu;
        }
-       geom_attr.aperture_start = 0;
-       geom_attr.aperture_end =
-               ((dma_addr_t)1 << min(8 * sizeof(dma_addr_t), (size_t)36)) - 1;
-       geom_attr.force_aperture = true;
-       ret = iommu_domain_set_attr(pcfg->iommu_domain, DOMAIN_ATTR_GEOMETRY,
-                                   &geom_attr);
-       if (ret < 0) {
-               dev_err(dev, "%s(): iommu_domain_set_attr() = %d", __func__,
-                       ret);
-               goto out_domain_free;
-       }
        ret = iommu_domain_set_attr(pcfg->iommu_domain, DOMAIN_ATTR_WINDOWS,
                                    &window_count);
        if (ret < 0) {