int arizona_irq_exit(struct arizona *arizona) { free_irq(arizona_map_irq(arizona, ARIZONA_IRQ_CTRLIF_ERR), arizona); free_irq(arizona_map_irq(arizona, ARIZONA_IRQ_BOOT_DONE), arizona); regmap_del_irq_chip(arizona->irq, arizona->irq_chip); regmap_del_irq_chip(arizona->irq, arizona->aod_irq_chip); free_irq(arizona->irq, arizona); return 0; }
static int max8907_i2c_remove(struct i2c_client *i2c) { struct max8907 *max8907 = i2c_get_clientdata(i2c); mfd_remove_devices(max8907->dev); regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_rtc); regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_on_off); regmap_del_irq_chip(max8907->i2c_gen->irq, max8907->irqc_chg); i2c_unregister_device(max8907->i2c_rtc); return 0; }
static int max77686_i2c_remove(struct i2c_client *i2c) { struct max77686_dev *max77686 = i2c_get_clientdata(i2c); mfd_remove_devices(max77686->dev); regmap_del_irq_chip(max77686->irq, max77686->rtc_irq_data); regmap_del_irq_chip(max77686->irq, max77686->irq_data); if (max77686->type == TYPE_MAX77686) i2c_unregister_device(max77686->rtc); return 0; }
int arizona_irq_exit(struct arizona *arizona) { if (arizona->ctrlif_error) free_irq(arizona_map_irq(arizona, ARIZONA_IRQ_CTRLIF_ERR), arizona); free_irq(arizona_map_irq(arizona, ARIZONA_IRQ_BOOT_DONE), arizona); regmap_del_irq_chip(irq_create_mapping(arizona->virq, 1), arizona->irq_chip); regmap_del_irq_chip(irq_create_mapping(arizona->virq, 0), arizona->aod_irq_chip); free_irq(arizona->irq, arizona); return 0; }
int da9052_irq_exit(struct da9052 *da9052) { da9052_free_irq(da9052, DA9052_IRQ_ADC_EOM, da9052); regmap_del_irq_chip(da9052->chip_irq, da9052->irq_data); return 0; }
int da9052_irq_init(struct da9052 *da9052) { int ret; ret = regmap_add_irq_chip(da9052->regmap, da9052->chip_irq, IRQF_TRIGGER_LOW | IRQF_ONESHOT, -1, &da9052_regmap_irq_chip, &da9052->irq_data); if (ret < 0) { dev_err(da9052->dev, "regmap_add_irq_chip failed: %d\n", ret); goto regmap_err; } enable_irq_wake(da9052->chip_irq); ret = da9052_request_irq(da9052, DA9052_IRQ_ADC_EOM, "adc-irq", da9052_auxadc_irq, da9052); if (ret != 0) { dev_err(da9052->dev, "DA9052_IRQ_ADC_EOM failed: %d\n", ret); goto request_irq_err; } return 0; request_irq_err: regmap_del_irq_chip(da9052->chip_irq, da9052->irq_data); regmap_err: return ret; }
static int max77693_i2c_remove(struct i2c_client *i2c) { struct max77693_dev *max77693 = i2c_get_clientdata(i2c); mfd_remove_devices(max77693->dev); regmap_del_irq_chip(max77693->irq, max77693->irq_data_muic); regmap_del_irq_chip(max77693->irq, max77693->irq_data_charger); regmap_del_irq_chip(max77693->irq, max77693->irq_data_topsys); regmap_del_irq_chip(max77693->irq, max77693->irq_data_led); i2c_unregister_device(max77693->muic); i2c_unregister_device(max77693->haptic); return 0; }
static int tps65090_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct tps65090_platform_data *pdata = client->dev.platform_data; int irq_base = 0; struct tps65090 *tps65090; int ret; if (!pdata && !client->dev.of_node) { dev_err(&client->dev, "tps65090 requires platform data or of_node\n"); return -EINVAL; } if (pdata) irq_base = pdata->irq_base; tps65090 = devm_kzalloc(&client->dev, sizeof(*tps65090), GFP_KERNEL); if (!tps65090) { dev_err(&client->dev, "mem alloc for tps65090 failed\n"); return -ENOMEM; } tps65090->dev = &client->dev; i2c_set_clientdata(client, tps65090); tps65090->rmap = devm_regmap_init_i2c(client, &tps65090_regmap_config); if (IS_ERR(tps65090->rmap)) { ret = PTR_ERR(tps65090->rmap); dev_err(&client->dev, "regmap_init failed with err: %d\n", ret); return ret; } if (client->irq) { ret = regmap_add_irq_chip(tps65090->rmap, client->irq, IRQF_ONESHOT | IRQF_TRIGGER_LOW, irq_base, &tps65090_irq_chip, &tps65090->irq_data); if (ret) { dev_err(&client->dev, "IRQ init failed with err: %d\n", ret); return ret; } } ret = mfd_add_devices(tps65090->dev, -1, tps65090s, ARRAY_SIZE(tps65090s), NULL, 0, regmap_irq_get_domain(tps65090->irq_data)); if (ret) { dev_err(&client->dev, "add mfd devices failed with err: %d\n", ret); goto err_irq_exit; } return 0; err_irq_exit: if (client->irq) regmap_del_irq_chip(client->irq, tps65090->irq_data); return ret; }
int axp20x_device_probe(struct axp20x_dev *axp20x) { int ret; /* * The AXP806 supports either master/standalone or slave mode. * Slave mode allows sharing the serial bus, even with multiple * AXP806 which all have the same hardware address. * * This is done with extra "serial interface address extension", * or AXP806_BUS_ADDR_EXT, and "register address extension", or * AXP806_REG_ADDR_EXT, registers. The former is read-only, with * 1 bit customizable at the factory, and 1 bit depending on the * state of an external pin. The latter is writable. The device * will only respond to operations to its other registers when * the these device addressing bits (in the upper 4 bits of the * registers) match. * * By default we support an AXP806 chained to an AXP809 in slave * mode. Boards which use an AXP806 in master mode can set the * property "x-powers,master-mode" to override the default. */ if (axp20x->variant == AXP806_ID) { if (of_property_read_bool(axp20x->dev->of_node, "x-powers,master-mode") || of_property_read_bool(axp20x->dev->of_node, "x-powers,self-working-mode")) regmap_write(axp20x->regmap, AXP806_REG_ADDR_EXT, AXP806_REG_ADDR_EXT_ADDR_MASTER_MODE); else regmap_write(axp20x->regmap, AXP806_REG_ADDR_EXT, AXP806_REG_ADDR_EXT_ADDR_SLAVE_MODE); } ret = regmap_add_irq_chip(axp20x->regmap, axp20x->irq, IRQF_ONESHOT | IRQF_SHARED | axp20x->irq_flags, -1, axp20x->regmap_irq_chip, &axp20x->regmap_irqc); if (ret) { dev_err(axp20x->dev, "failed to add irq chip: %d\n", ret); return ret; } ret = mfd_add_devices(axp20x->dev, -1, axp20x->cells, axp20x->nr_cells, NULL, 0, NULL); if (ret) { dev_err(axp20x->dev, "failed to add MFD devices: %d\n", ret); regmap_del_irq_chip(axp20x->irq, axp20x->regmap_irqc); return ret; } if (!pm_power_off) { axp20x_pm_power_off = axp20x; pm_power_off = axp20x_power_off; } dev_info(axp20x->dev, "AXP20X driver loaded\n"); return 0; }
static int hi655x_pmic_remove(struct platform_device *pdev) { struct hi655x_pmic *pmic = platform_get_drvdata(pdev); regmap_del_irq_chip(gpio_to_irq(pmic->gpio), pmic->irq_data); mfd_remove_devices(&pdev->dev); return 0; }
static int __devexit max77660_remove(struct i2c_client *client) { struct max77660_chip *chip = i2c_get_clientdata(client); struct max77660_platform_data *pdata = client->dev.platform_data; int i; mfd_remove_devices(chip->dev); regmap_del_irq_chip(pdata->irq_base + MAX77660_IRQ_GLBL_BASE, chip->global_irq_data); regmap_del_irq_chip(chip->chip_irq, chip->top_irq_data); for (i = 0; i < MAX77660_NUM_SLAVES; i++) { if (chip->clients[i] != client) i2c_unregister_device(chip->clients[i]); } max77660_chip = NULL; return 0; }
static int bd9571mwv_remove(struct i2c_client *client) { struct bd9571mwv *bd = i2c_get_clientdata(client); regmap_del_irq_chip(bd->irq, bd->irq_data); return 0; }
static int as3722_i2c_remove(struct i2c_client *i2c) { struct as3722 *as3722 = i2c_get_clientdata(i2c); mfd_remove_devices(as3722->dev); regmap_del_irq_chip(as3722->chip_irq, as3722->irq_data); return 0; }
static int da9062_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct da9062 *chip; unsigned int irq_base; int ret; chip = devm_kzalloc(&i2c->dev, sizeof(*chip), GFP_KERNEL); if (!chip) return -ENOMEM; i2c_set_clientdata(i2c, chip); chip->dev = &i2c->dev; if (!i2c->irq) { dev_err(chip->dev, "No IRQ configured\n"); return -EINVAL; } chip->regmap = devm_regmap_init_i2c(i2c, &da9062_regmap_config); if (IS_ERR(chip->regmap)) { ret = PTR_ERR(chip->regmap); dev_err(chip->dev, "Failed to allocate register map: %d\n", ret); return ret; } ret = da9062_clear_fault_log(chip); if (ret < 0) dev_warn(chip->dev, "Cannot clear fault log\n"); ret = da9062_get_device_type(chip); if (ret) return ret; ret = regmap_add_irq_chip(chip->regmap, i2c->irq, IRQF_TRIGGER_LOW | IRQF_ONESHOT | IRQF_SHARED, -1, &da9062_irq_chip, &chip->regmap_irq); if (ret) { dev_err(chip->dev, "Failed to request IRQ %d: %d\n", i2c->irq, ret); return ret; } irq_base = regmap_irq_chip_get_base(chip->regmap_irq); ret = mfd_add_devices(chip->dev, PLATFORM_DEVID_NONE, da9062_devs, ARRAY_SIZE(da9062_devs), NULL, irq_base, NULL); if (ret) { dev_err(chip->dev, "Cannot register child devices\n"); regmap_del_irq_chip(i2c->irq, chip->regmap_irq); return ret; } return ret; }
static int as3722_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct as3722 *as3722; unsigned long irq_flags; int ret; as3722 = devm_kzalloc(&i2c->dev, sizeof(struct as3722), GFP_KERNEL); if (!as3722) return -ENOMEM; as3722->dev = &i2c->dev; as3722->chip_irq = i2c->irq; i2c_set_clientdata(i2c, as3722); ret = as3722_i2c_of_probe(i2c, as3722); if (ret < 0) return ret; as3722->regmap = devm_regmap_init_i2c(i2c, &as3722_regmap_config); if (IS_ERR(as3722->regmap)) { ret = PTR_ERR(as3722->regmap); dev_err(&i2c->dev, "regmap init failed: %d\n", ret); return ret; } ret = as3722_check_device_id(as3722); if (ret < 0) return ret; irq_flags = as3722->irq_flags | IRQF_ONESHOT; ret = regmap_add_irq_chip(as3722->regmap, as3722->chip_irq, irq_flags, -1, &as3722_irq_chip, &as3722->irq_data); if (ret < 0) { dev_err(as3722->dev, "Failed to add regmap irq: %d\n", ret); return ret; } ret = as3722_configure_pullups(as3722); if (ret < 0) goto scrub; ret = mfd_add_devices(&i2c->dev, -1, as3722_devs, ARRAY_SIZE(as3722_devs), NULL, 0, regmap_irq_get_domain(as3722->irq_data)); if (ret) { dev_err(as3722->dev, "Failed to add MFD devices: %d\n", ret); goto scrub; } dev_dbg(as3722->dev, "AS3722 core driver initialized successfully\n"); return 0; scrub: regmap_del_irq_chip(as3722->chip_irq, as3722->irq_data); return ret; }
static int da9150_remove(struct i2c_client *client) { struct da9150 *da9150 = i2c_get_clientdata(client); regmap_del_irq_chip(da9150->irq, da9150->regmap_irq_data); mfd_remove_devices(da9150->dev); return 0; }
static int da9062_i2c_remove(struct i2c_client *i2c) { struct da9062 *chip = i2c_get_clientdata(i2c); mfd_remove_devices(chip->dev); regmap_del_irq_chip(i2c->irq, chip->regmap_irq); return 0; }
static int max14577_i2c_remove(struct i2c_client *i2c) { struct max14577 *max14577 = i2c_get_clientdata(i2c); mfd_remove_devices(max14577->dev); regmap_del_irq_chip(max14577->irq, max14577->irq_data); return 0; }
static int palmas_i2c_remove(struct i2c_client *i2c) { struct palmas *palmas = i2c_get_clientdata(i2c); mfd_remove_devices(palmas->dev); regmap_del_irq_chip(palmas->irq, palmas->irq_data); return 0; }
static int intel_soc_pmic_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *i2c_id) { struct device *dev = &i2c->dev; const struct acpi_device_id *id; struct intel_soc_pmic_config *config; struct intel_soc_pmic *pmic; int ret; id = acpi_match_device(dev->driver->acpi_match_table, dev); if (!id || !id->driver_data) return -ENODEV; config = (struct intel_soc_pmic_config *)id->driver_data; pmic = devm_kzalloc(dev, sizeof(*pmic), GFP_KERNEL); if (!pmic) return -ENOMEM; dev_set_drvdata(dev, pmic); pmic->regmap = devm_regmap_init_i2c(i2c, config->regmap_config); if (IS_ERR(pmic->regmap)) return PTR_ERR(pmic->regmap); pmic->irq = i2c->irq; ret = regmap_add_irq_chip(pmic->regmap, pmic->irq, config->irq_flags | IRQF_ONESHOT, 0, config->irq_chip, &pmic->irq_chip_data); if (ret) return ret; ret = enable_irq_wake(pmic->irq); if (ret) dev_warn(dev, "Can't enable IRQ as wake source: %d\n", ret); /* Add lookup table binding for Panel Control to the GPIO Chip */ gpiod_add_lookup_table(&panel_gpio_table); /* Add lookup table for crc-pwm */ pwm_add_table(crc_pwm_lookup, ARRAY_SIZE(crc_pwm_lookup)); ret = mfd_add_devices(dev, -1, config->cell_dev, config->n_cell_devs, NULL, 0, regmap_irq_get_domain(pmic->irq_chip_data)); if (ret) goto err_del_irq_chip; return 0; err_del_irq_chip: regmap_del_irq_chip(pmic->irq, pmic->irq_chip_data); return ret; }
int mc13xxx_common_exit(struct device *dev) { struct mc13xxx *mc13xxx = dev_get_drvdata(dev); mfd_remove_devices(dev); regmap_del_irq_chip(mc13xxx->irq, mc13xxx->irq_data); mutex_destroy(&mc13xxx->lock); return 0; }
static int tps65090_i2c_remove(struct i2c_client *client) { struct tps65090 *tps65090 = i2c_get_clientdata(client); mfd_remove_devices(tps65090->dev); if (client->irq) regmap_del_irq_chip(client->irq, tps65090->irq_data); return 0; }
int axp20x_device_remove(struct axp20x_dev *axp20x) { if (axp20x == axp20x_pm_power_off) { axp20x_pm_power_off = NULL; pm_power_off = NULL; } mfd_remove_devices(axp20x->dev); regmap_del_irq_chip(axp20x->irq, axp20x->regmap_irqc); return 0; }
static int max77843_remove(struct i2c_client *i2c) { struct max77843 *max77843 = i2c_get_clientdata(i2c); mfd_remove_devices(max77843->dev); regmap_del_irq_chip(max77843->irq, max77843->irq_data); i2c_unregister_device(max77843->i2c_chg); return 0; }
static int axp20x_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct axp20x_dev *axp20x; int ret; axp20x = devm_kzalloc(&i2c->dev, sizeof(*axp20x), GFP_KERNEL); if (!axp20x) return -ENOMEM; ret = axp20x_match_device(axp20x, &i2c->dev); if (ret) return ret; axp20x->i2c_client = i2c; axp20x->dev = &i2c->dev; dev_set_drvdata(axp20x->dev, axp20x); axp20x->regmap = devm_regmap_init_i2c(i2c, axp20x->regmap_cfg); if (IS_ERR(axp20x->regmap)) { ret = PTR_ERR(axp20x->regmap); dev_err(&i2c->dev, "regmap init failed: %d\n", ret); return ret; } ret = regmap_add_irq_chip(axp20x->regmap, i2c->irq, IRQF_ONESHOT | IRQF_SHARED, -1, axp20x->regmap_irq_chip, &axp20x->regmap_irqc); if (ret) { dev_err(&i2c->dev, "failed to add irq chip: %d\n", ret); return ret; } ret = mfd_add_devices(axp20x->dev, -1, axp20x->cells, axp20x->nr_cells, NULL, 0, NULL); if (ret) { dev_err(&i2c->dev, "failed to add MFD devices: %d\n", ret); regmap_del_irq_chip(i2c->irq, axp20x->regmap_irqc); return ret; } if (!pm_power_off) { axp20x_pm_power_off = axp20x; pm_power_off = axp20x_power_off; } dev_info(&i2c->dev, "AXP20X driver loaded\n"); return 0; }
static int madera_irq_remove(struct platform_device *pdev) { struct madera *madera = dev_get_drvdata(pdev->dev.parent); /* * The IRQ is disabled by the parent MFD driver before * it starts cleaning up all child drivers */ madera->irq_dev = NULL; regmap_del_irq_chip(madera->irq, madera->irq_data); return 0; }
static int axp20x_i2c_remove(struct i2c_client *i2c) { struct axp20x_dev *axp20x = i2c_get_clientdata(i2c); if (axp20x == axp20x_pm_power_off) { axp20x_pm_power_off = NULL; pm_power_off = NULL; } mfd_remove_devices(axp20x->dev); regmap_del_irq_chip(axp20x->i2c_client->irq, axp20x->regmap_irqc); return 0; }
static int twl6040_remove(struct i2c_client *client) { struct twl6040 *twl6040 = i2c_get_clientdata(client); if (twl6040->power_count) twl6040_power(twl6040, 0); regmap_del_irq_chip(twl6040->irq, twl6040->irq_data); mfd_remove_devices(&client->dev); regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies); return 0; }
static int intel_soc_pmic_i2c_remove(struct i2c_client *i2c) { struct intel_soc_pmic *pmic = dev_get_drvdata(&i2c->dev); regmap_del_irq_chip(pmic->irq, pmic->irq_chip_data); /* Remove lookup table for Panel Control from the GPIO Chip */ gpiod_remove_lookup_table(&panel_gpio_table); /* remove crc-pwm lookup table */ pwm_remove_table(crc_pwm_lookup, ARRAY_SIZE(crc_pwm_lookup)); mfd_remove_devices(&i2c->dev); return 0; }
static int da9150_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct da9150 *da9150; struct da9150_pdata *pdata = dev_get_platdata(&client->dev); int ret; da9150 = devm_kzalloc(&client->dev, sizeof(*da9150), GFP_KERNEL); if (!da9150) return -ENOMEM; da9150->dev = &client->dev; da9150->irq = client->irq; i2c_set_clientdata(client, da9150); da9150->regmap = devm_regmap_init_i2c(client, &da9150_regmap_config); if (IS_ERR(da9150->regmap)) { ret = PTR_ERR(da9150->regmap); dev_err(da9150->dev, "Failed to allocate register map: %d\n", ret); return ret; } da9150->irq_base = pdata ? pdata->irq_base : -1; ret = regmap_add_irq_chip(da9150->regmap, da9150->irq, IRQF_TRIGGER_LOW | IRQF_ONESHOT, da9150->irq_base, &da9150_regmap_irq_chip, &da9150->regmap_irq_data); if (ret) return ret; da9150->irq_base = regmap_irq_chip_get_base(da9150->regmap_irq_data); enable_irq_wake(da9150->irq); ret = mfd_add_devices(da9150->dev, -1, da9150_devs, ARRAY_SIZE(da9150_devs), NULL, da9150->irq_base, NULL); if (ret) { dev_err(da9150->dev, "Failed to add child devices: %d\n", ret); regmap_del_irq_chip(da9150->irq, da9150->regmap_irq_data); return ret; } return 0; }