static int __init fail_iommu_setup(void) { #ifdef CONFIG_PCI bus_register_notifier(&pci_bus_type, &fail_iommu_bus_notifier); #endif #ifdef CONFIG_IBMVIO bus_register_notifier(&vio_bus_type, &fail_iommu_bus_notifier); #endif return 0; }
static int __init coherency_late_init(void) { if (of_find_matching_node(NULL, of_coherency_table)) bus_register_notifier(&platform_bus_type, &mvebu_hwcc_platform_nb); return 0; }
static int __init register_xen_amba_notifier(void) { if (!xen_initial_domain() || acpi_disabled) return 0; return bus_register_notifier(&amba_bustype, &amba_device_nb); }
static int __init rcar_gen2_regulator_quirk(void) { u32 mon; if (!of_machine_is_compatible("renesas,koelsch") && !of_machine_is_compatible("renesas,lager") && !of_machine_is_compatible("renesas,gose")) return -ENODEV; irqc = ioremap(IRQC_BASE, PAGE_SIZE); if (!irqc) return -ENOMEM; mon = ioread32(irqc + IRQC_MONITOR); if (mon & REGULATOR_IRQ_MASK) { pr_debug("%s: IRQ2 is not asserted, not installing quirk\n", __func__); iounmap(irqc); return 0; } pr_info("IRQ2 is asserted, installing da9063/da9210 regulator quirk\n"); bus_register_notifier(&i2c_bus_type, ®ulator_quirk_nb); return 0; }
static int __init cma_init_reserved_areas(void) { struct cma *cma; int i; for (i = 0; i < cma_area_count; i++) { phys_addr_t base = PFN_DOWN(cma_areas[i].base); unsigned int count = cma_areas[i].size >> PAGE_SHIFT; cma = cma_create_area(base, count); if (!IS_ERR(cma)) cma_areas[i].cma = cma; } dma_contiguous_def_area = cma_get_area(dma_contiguous_def_base); for (i = 0; i < cma_map_count; i++) { cma = cma_get_area(cma_maps[i].base); dev_set_cma_area(cma_maps[i].dev, cma); } #ifdef CONFIG_OF bus_register_notifier(&platform_bus_type, &cma_dev_init_nb); #endif return 0; }
struct device *mcuio_add_soft_hc(struct mcuio_device_id *id, const struct mcuio_soft_hc_ops *ops, void *priv) { struct mcuio_hc_platform_data *plat; struct mcuio_soft_hc *shc = __setup_shc(ops, priv); struct device *out; int stat; if (IS_ERR(shc)) return ERR_PTR(PTR_ERR(shc)); plat = kzalloc(sizeof(*plat), GFP_KERNEL); if (!plat) { kfree(shc); return ERR_PTR(-ENOMEM); } plat->setup_regmap = mcuio_soft_hc_setup_regmap; plat->data = shc; stat = bus_register_notifier(&mcuio_bus_type, &device_nb); if (stat < 0) { kfree(shc); return ERR_PTR(stat); } out = mcuio_add_hc_device(id ? id : &default_soft_hc_id, plat, mcuio_soft_hc_release); if (IS_ERR(out)) { kfree(shc); bus_unregister_notifier(&mcuio_bus_type, &device_nb); return out; } shc->hc = to_mcuio_dev(out); return out; }
static void __init keystone_init(void) { keystone_pm_runtime_init(); if (platform_nb.notifier_call) bus_register_notifier(&platform_bus_type, &platform_nb); of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); }
static int __init sh_pm_runtime_init(void) { INIT_WORK(&hwblk_work, platform_pm_runtime_work); bus_register_notifier(&platform_bus_type, &platform_bus_notifier); return 0; }
static void __init pdm360ng_touchscreen_init(void) { if (pdm360ng_penirq_init()) return; bus_register_notifier(&spi_bus_type, &pdm360ng_touchscreen_nb); }
static int __init register_xen_platform_notifier(void) { if (!xen_initial_domain() || acpi_disabled) return 0; return bus_register_notifier(&platform_bus_type, &platform_device_nb); }
void qcom_pm_add_notifier(struct gdsc_notifier_block *gdsc_nb) { if (!gdsc_nb) return; gdsc_nb->nb.notifier_call = clk_notify, bus_register_notifier(&platform_bus_type, &gdsc_nb->nb); }
/* * Init */ static int __init usb_init(void) { int retval; if (nousb) { pr_info("%s: USB support disabled\n", usbcore_name); return 0; } retval = usb_debugfs_init(); if (retval) goto out; retval = ksuspend_usb_init(); if (retval) goto out; retval = bus_register(&usb_bus_type); if (retval) goto bus_register_failed; retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb); if (retval) goto bus_notifier_failed; retval = usb_major_init(); if (retval) goto major_init_failed; retval = usb_register(&usbfs_driver); if (retval) goto driver_register_failed; retval = usb_devio_init(); if (retval) goto usb_devio_init_failed; retval = usbfs_init(); if (retval) goto fs_init_failed; retval = usb_hub_init(); if (retval) goto hub_init_failed; retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE); if (!retval) goto out; usb_hub_cleanup(); hub_init_failed: usbfs_cleanup(); fs_init_failed: usb_devio_cleanup(); usb_devio_init_failed: usb_deregister(&usbfs_driver); driver_register_failed: usb_major_cleanup(); major_init_failed: bus_unregister_notifier(&usb_bus_type, &usb_bus_nb); bus_notifier_failed: bus_unregister(&usb_bus_type); bus_register_failed: ksuspend_usb_cleanup(); out: return retval; }
static void __init keystone_init(void) { if (PHYS_OFFSET >= KEYSTONE_HIGH_PHYS_START) { keystone_dma_pfn_offset = PFN_DOWN(KEYSTONE_HIGH_PHYS_START - KEYSTONE_LOW_PHYS_START); bus_register_notifier(&platform_bus_type, &platform_nb); } keystone_pm_runtime_init(); }
static int __init init_ccwgroup(void) { int ret; ret = bus_register(&ccwgroup_bus_type); if (ret) return ret; ret = bus_register_notifier(&ccwgroup_bus_type, &ccwgroup_nb); if (ret) bus_unregister(&ccwgroup_bus_type); return ret; }
static int __init coherency_late_init(void) { struct device_node *np; if (!is_smp()) return 0; np = of_find_matching_node(NULL, of_coherency_table); if (np) { bus_register_notifier(&platform_bus_type, &mvebu_hwcc_platform_nb); of_node_put(np); } return 0; }
void i2c_dev_init(void) { int res; /* printk(KERN_INFO "i2c /dev entries driver\n"); res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops); if (res) goto out; */ i2c_dev_class = class_create(THIS_MODULE, "i2c-dev"); if (IS_ERR(i2c_dev_class)) { res = PTR_ERR(i2c_dev_class); return; //goto out_unreg_chrdev; } /* Keep track of adapters which will be added or removed later */ res = bus_register_notifier(&i2c_bus_type, &i2cdev_notifier); if (res) return; /* Bind to already existing adapters right away */ i2c_for_each_dev(NULL, i2cdev_attach_adapter); }
int exynos_drm_iommu_unregister(void) { return bus_register_notifier(&platform_bus_type, &exynos_drm_iommu_notifier); }
int exynos_drm_iommu_register(struct platform_driver **drivers, int count) { exynos_drm_subdrivers = drivers; exynos_drm_subdrivers_count = count; return bus_register_notifier(&platform_bus_type, &exynos_drm_iommu_notifier); }
/* * The amba bus itself gets registered in a core_initcall, so we can't use * that. */ static int __init ux500_pm_runtime_amba_init(void) { bus_register_notifier(&amba_bustype, &ux500_pd_amba_notifier); return 0; }
static int __init setup_bus_notifier(void) { bus_register_notifier(&platform_bus_type, &dflt_plat_bus_notifier); return 0; }
static int __init omap_device_init(void) { bus_register_notifier(&platform_bus_type, &platform_nb); return 0; }
static int __init ux500_pm_runtime_platform_init(void) { bus_register_notifier(&platform_bus_type, &ux500_pd_platform_notifier); return 0; }
int __init swiotlb_setup_bus_notifier(void) { bus_register_notifier(&platform_bus_type, &ppc_swiotlb_plat_bus_notifier); return 0; }
static void iommu_bus_init(struct bus_type *bus, struct iommu_ops *ops) { bus_register_notifier(bus, &iommu_device_nb); bus_for_each_dev(bus, NULL, NULL, add_iommu_group); }
static int xen_add_device(struct device *dev) { int r; struct pci_dev *pci_dev = to_pci_dev(dev); #ifdef CONFIG_PCI_IOV struct pci_dev *physfn = pci_dev->physfn; #endif if (pci_seg_supported) { struct physdev_pci_device_add add = { .seg = pci_domain_nr(pci_dev->bus), .bus = pci_dev->bus->number, .devfn = pci_dev->devfn }; #ifdef CONFIG_ACPI acpi_handle handle; #endif #ifdef CONFIG_PCI_IOV if (pci_dev->is_virtfn) { add.flags = XEN_PCI_DEV_VIRTFN; add.physfn.bus = physfn->bus->number; add.physfn.devfn = physfn->devfn; } else #endif if (pci_ari_enabled(pci_dev->bus) && PCI_SLOT(pci_dev->devfn)) add.flags = XEN_PCI_DEV_EXTFN; #ifdef CONFIG_ACPI handle = DEVICE_ACPI_HANDLE(&pci_dev->dev); if (!handle) handle = DEVICE_ACPI_HANDLE(pci_dev->bus->bridge); #ifdef CONFIG_PCI_IOV if (!handle && pci_dev->is_virtfn) handle = DEVICE_ACPI_HANDLE(physfn->bus->bridge); #endif if (handle) { acpi_status status; do { unsigned long long pxm; status = acpi_evaluate_integer(handle, "_PXM", NULL, &pxm); if (ACPI_SUCCESS(status)) { add.optarr[0] = pxm; add.flags |= XEN_PCI_DEV_PXM; break; } status = acpi_get_parent(handle, &handle); } while (ACPI_SUCCESS(status)); } #endif /* CONFIG_ACPI */ r = HYPERVISOR_physdev_op(PHYSDEVOP_pci_device_add, &add); if (r != -ENOSYS) return r; pci_seg_supported = false; } if (pci_domain_nr(pci_dev->bus)) r = -ENOSYS; #ifdef CONFIG_PCI_IOV else if (pci_dev->is_virtfn) { struct physdev_manage_pci_ext manage_pci_ext = { .bus = pci_dev->bus->number, .devfn = pci_dev->devfn, .is_virtfn = 1, .physfn.bus = physfn->bus->number, .physfn.devfn = physfn->devfn, }; r = HYPERVISOR_physdev_op(PHYSDEVOP_manage_pci_add_ext, &manage_pci_ext); } #endif else if (pci_ari_enabled(pci_dev->bus) && PCI_SLOT(pci_dev->devfn)) { struct physdev_manage_pci_ext manage_pci_ext = { .bus = pci_dev->bus->number, .devfn = pci_dev->devfn, .is_extfn = 1, }; r = HYPERVISOR_physdev_op(PHYSDEVOP_manage_pci_add_ext, &manage_pci_ext); } else { struct physdev_manage_pci manage_pci = { .bus = pci_dev->bus->number, .devfn = pci_dev->devfn, }; r = HYPERVISOR_physdev_op(PHYSDEVOP_manage_pci_add, &manage_pci); } return r; } static int xen_remove_device(struct device *dev) { int r; struct pci_dev *pci_dev = to_pci_dev(dev); if (pci_seg_supported) { struct physdev_pci_device device = { .seg = pci_domain_nr(pci_dev->bus), .bus = pci_dev->bus->number, .devfn = pci_dev->devfn }; r = HYPERVISOR_physdev_op(PHYSDEVOP_pci_device_remove, &device); } else if (pci_domain_nr(pci_dev->bus)) r = -ENOSYS; else { struct physdev_manage_pci manage_pci = { .bus = pci_dev->bus->number, .devfn = pci_dev->devfn }; r = HYPERVISOR_physdev_op(PHYSDEVOP_manage_pci_remove, &manage_pci); } return r; } static int xen_pci_notifier(struct notifier_block *nb, unsigned long action, void *data) { struct device *dev = data; int r = 0; switch (action) { case BUS_NOTIFY_ADD_DEVICE: r = xen_add_device(dev); break; case BUS_NOTIFY_DEL_DEVICE: r = xen_remove_device(dev); break; default: return NOTIFY_DONE; } if (r) dev_err(dev, "Failed to %s - passthrough or MSI/MSI-X might fail!\n", action == BUS_NOTIFY_ADD_DEVICE ? "add" : (action == BUS_NOTIFY_DEL_DEVICE ? "delete" : "?")); return NOTIFY_OK; } static struct notifier_block device_nb = { .notifier_call = xen_pci_notifier, }; static int __init register_xen_pci_notifier(void) { if (!xen_initial_domain()) return 0; return bus_register_notifier(&pci_bus_type, &device_nb); } arch_initcall(register_xen_pci_notifier);