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, &regulator_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 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 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;
}