static void domain_exit(struct dmar_domain *domain);
 static void domain_remove_dev_info(struct dmar_domain *domain);
 static void domain_remove_one_dev_info(struct dmar_domain *domain,
-                                      struct pci_dev *pdev);
+                                      struct device *dev);
 static void iommu_detach_dependent_devices(struct intel_iommu *iommu,
                                           struct device *dev);
 
 
        ret = domain_context_mapping(domain, &pdev->dev, translation);
        if (ret) {
-               domain_remove_one_dev_info(domain, pdev);
+               domain_remove_one_dev_info(domain, &pdev->dev);
                return ret;
        }
 
                         * 32 bit DMA is removed from si_domain and fall back
                         * to non-identity mapping.
                         */
-                       domain_remove_one_dev_info(si_domain, pdev);
+                       domain_remove_one_dev_info(si_domain, dev);
                        printk(KERN_INFO "32bit %s uses non-identity mapping\n",
                               pci_name(pdev));
                        return 0;
                                  unsigned long action, void *data)
 {
        struct device *dev = data;
-       struct pci_dev *pdev = to_pci_dev(dev);
        struct dmar_domain *domain;
 
        if (iommu_dummy(dev))
                return 0;
 
        down_read(&dmar_global_lock);
-       domain_remove_one_dev_info(domain, pdev);
+       domain_remove_one_dev_info(domain, dev);
        if (!(domain->flags & DOMAIN_FLAG_VIRTUAL_MACHINE) &&
            !(domain->flags & DOMAIN_FLAG_STATIC_IDENTITY) &&
            list_empty(&domain->devices))
 }
 
 static void domain_remove_one_dev_info(struct dmar_domain *domain,
-                                         struct pci_dev *pdev)
+                                      struct device *dev)
 {
        struct device_domain_info *info, *tmp;
        struct intel_iommu *iommu;
        int found = 0;
        u8 bus, devfn;
 
-       iommu = device_to_iommu(&pdev->dev, &bus, &devfn);
+       iommu = device_to_iommu(dev, &bus, &devfn);
        if (!iommu)
                return;
 
        spin_lock_irqsave(&device_domain_lock, flags);
        list_for_each_entry_safe(info, tmp, &domain->devices, link) {
-               if (info->iommu->segment == pci_domain_nr(pdev->bus) &&
-                   info->bus == pdev->bus->number &&
-                   info->devfn == pdev->devfn) {
+               if (info->iommu == iommu && info->bus == bus &&
+                   info->devfn == devfn) {
                        unlink_domain_info(info);
                        spin_unlock_irqrestore(&device_domain_lock, flags);
 
                        iommu_disable_dev_iotlb(info);
                        iommu_detach_dev(iommu, info->bus, info->devfn);
-                       iommu_detach_dependent_devices(iommu, &pdev->dev);
+                       iommu_detach_dependent_devices(iommu, dev);
                        free_devinfo_mem(info);
 
                        spin_lock_irqsave(&device_domain_lock, flags);
                if (old_domain) {
                        if (dmar_domain->flags & DOMAIN_FLAG_VIRTUAL_MACHINE ||
                            dmar_domain->flags & DOMAIN_FLAG_STATIC_IDENTITY)
-                               domain_remove_one_dev_info(old_domain, pdev);
+                               domain_remove_one_dev_info(old_domain, dev);
                        else
                                domain_remove_dev_info(old_domain);
                }
                                      struct device *dev)
 {
        struct dmar_domain *dmar_domain = domain->priv;
-       struct pci_dev *pdev = to_pci_dev(dev);
 
-       domain_remove_one_dev_info(dmar_domain, pdev);
+       domain_remove_one_dev_info(dmar_domain, dev);
 }
 
 static int intel_iommu_map(struct iommu_domain *domain,