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;
}
/*
* 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;
}
/*
* Cleanup
*/
static void __exit usb_exit(void)
{
/* This will matter if shutdown/reboot does exitcalls. */
if (nousb)
return;
usb_deregister_device_driver(&usb_generic_driver);
usb_major_cleanup();
usbfs_cleanup();
usb_deregister(&usbfs_driver);
usb_devio_cleanup();
usb_hub_cleanup();
bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
bus_unregister(&usb_bus_type);
usb_debugfs_cleanup();
}
static void __exit usb_exit(void)
{
if (nousb)
return;
usb_deregister_device_driver(&usb_generic_driver);
usb_major_cleanup();
usbfs_cleanup();
usb_deregister(&usbfs_driver);
usb_devio_cleanup();
usb_hub_cleanup();
bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
bus_unregister(&usb_bus_type);
ksuspend_usb_cleanup();
usb_debugfs_cleanup();
}
/*
* Cleanup
*/
static void __exit usb_exit(void)
{
/* This will matter if shutdown/reboot does exitcalls. */
if (usb_disabled())
return;
usb_release_quirk_list();
usb_deregister_device_driver(&usb_generic_driver);
usb_major_cleanup();
usb_deregister(&usbfs_driver);
usb_devio_cleanup();
usb_hub_cleanup();
bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
bus_unregister(&usb_bus_type);
usb_acpi_unregister();
usb_debugfs_cleanup();
idr_destroy(&usb_bus_idr);
}
static int regulator_quirk_notify(struct notifier_block *nb,
unsigned long action, void *data)
{
struct device *dev = data;
struct i2c_client *client;
u32 mon;
mon = ioread32(irqc + IRQC_MONITOR);
dev_dbg(dev, "%s: %ld, IRQC_MONITOR = 0x%x\n", __func__, action, mon);
if (mon & REGULATOR_IRQ_MASK)
goto remove;
if (action != BUS_NOTIFY_ADD_DEVICE || dev->type == &i2c_adapter_type)
return 0;
client = to_i2c_client(dev);
dev_dbg(dev, "Detected %s\n", client->name);
if ((client->addr == 0x58 && !strcmp(client->name, "da9063")) ||
(client->addr == 0x68 && !strcmp(client->name, "da9210"))) {
int ret;
dev_info(&client->dev, "clearing da9063/da9210 interrupts\n");
ret = i2c_transfer(client->adapter, da9xxx_msgs, ARRAY_SIZE(da9xxx_msgs));
if (ret != ARRAY_SIZE(da9xxx_msgs))
dev_err(&client->dev, "i2c error %d\n", ret);
}
mon = ioread32(irqc + IRQC_MONITOR);
if (mon & REGULATOR_IRQ_MASK)
goto remove;
return 0;
remove:
dev_info(dev, "IRQ2 is not asserted, removing quirk\n");
bus_unregister_notifier(&i2c_bus_type, nb);
iounmap(irqc);
return 0;
}
static void mcuio_soft_hc_release(struct device *device)
{
struct mcuio_hc_platform_data *plat = dev_get_platdata(device);
struct mcuio_soft_hc *shc;
int i;
if (!plat) {
WARN_ON(1);
return;
}
shc = plat->data;
bus_unregister_notifier(&mcuio_bus_type, &device_nb);
/* Unregister all irq controllers */
for (i = 0; i < MCUIO_DEVS_PER_BUS; i++)
if (shc->irq_controllers[i])
mcuio_device_unregister(shc->irq_controllers[i]);
irq_set_handler(shc->irqno, NULL);
irq_set_chip(shc->irqno, NULL);
irq_free_desc(shc->irqno);
kfree(shc);
mcuio_hc_dev_default_release(device);
}
static void __exit cleanup_ccwgroup(void)
{
bus_unregister_notifier(&ccwgroup_bus_type, &ccwgroup_nb);
bus_unregister(&ccwgroup_bus_type);
}
void i2c_dev_exit(void) {
bus_unregister_notifier(&i2c_bus_type, &i2cdev_notifier);
i2c_for_each_dev(NULL, i2cdev_detach_adapter);
class_destroy(i2c_dev_class);
//unregister_chrdev(I2C_MAJOR, "i2c");
}
