/* * Core MFD support for Cirrus Logic Madera codecs * * Copyright 2015-2017 Cirrus Logic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "madera.h" #define CS47L15_SILICON_ID 0x6370 #define CS47L35_SILICON_ID 0x6360 #define CS47L85_SILICON_ID 0x6338 #define CS47L90_SILICON_ID 0x6364 #define CS47L92_SILICON_ID 0x6371 #define MADERA_32KZ_MCLK2 1 #define ERRATA_DCVDD_MIN_US 10000 #define ERRATA_DCVDD_MAX_US 15000 static const char * const madera_core_supplies[] = { "AVDD", "DBVDD1", }; static const struct mfd_cell madera_ldo1_devs[] = { { .name = "madera-ldo1" }, }; static const struct mfd_cell madera_pinctrl_dev[] = { { .name = "madera-pinctrl", .of_compatible = "cirrus,madera-pinctrl", }, }; static const char * const cs47l15_supplies[] = { "MICVDD", "CPVDD1", "SPKVDD", }; static const struct mfd_cell cs47l15_devs[] = { { .name = "madera-irq" }, { .name = "madera-gpio" }, { .name = "madera-extcon", .parent_supplies = cs47l15_supplies, .num_parent_supplies = 1, /* We only need MICVDD */ }, { .name = "cs47l15-codec", .parent_supplies = cs47l15_supplies, .num_parent_supplies = ARRAY_SIZE(cs47l15_supplies), }, }; static const char * const cs47l35_supplies[] = { "MICVDD", "DBVDD2", "CPVDD1", "CPVDD2", "SPKVDD", }; static const struct mfd_cell cs47l35_devs[] = { { .name = "madera-irq", }, { .name = "madera-micsupp" }, { .name = "madera-gpio", }, { .name = "madera-extcon", .parent_supplies = cs47l35_supplies, .num_parent_supplies = 1, /* We only need MICVDD */ }, { .name = "cs47l35-codec", .parent_supplies = cs47l35_supplies, .num_parent_supplies = ARRAY_SIZE(cs47l35_supplies), }, }; static const char * const cs47l85_supplies[] = { "MICVDD", "DBVDD2", "DBVDD3", "DBVDD4", "CPVDD1", "CPVDD2", "SPKVDDL", "SPKVDDR", }; static const struct mfd_cell cs47l85_devs[] = { { .name = "madera-irq", }, { .name = "madera-micsupp", }, { .name = "madera-gpio", }, { .name = "madera-extcon", .parent_supplies = cs47l85_supplies, .num_parent_supplies = 1, /* We only need MICVDD */ }, { .name = "cs47l85-codec", .parent_supplies = cs47l85_supplies, .num_parent_supplies = ARRAY_SIZE(cs47l85_supplies), }, }; static const char * const cs47l90_supplies[] = { "MICVDD", "DBVDD2", "DBVDD3", "DBVDD4", "CPVDD1", "CPVDD2", }; static const struct mfd_cell cs47l90_devs[] = { { .name = "madera-irq", }, { .name = "madera-micsupp", }, { .name = "madera-gpio", }, { .name = "madera-extcon", .parent_supplies = cs47l90_supplies, .num_parent_supplies = 1, /* We only need MICVDD */ }, { .name = "cs47l90-codec", .parent_supplies = cs47l90_supplies, .num_parent_supplies = ARRAY_SIZE(cs47l90_supplies), }, }; static const char * const cs47l92_supplies[] = { "MICVDD", "CPVDD1", "CPVDD2", }; static const struct mfd_cell cs47l92_devs[] = { { .name = "madera-irq", }, { .name = "madera-micsupp", }, { .name = "madera-gpio" }, { .name = "madera-extcon", .parent_supplies = cs47l92_supplies, .num_parent_supplies = 1, /* We only need MICVDD */ }, { .name = "cs47l92-codec", .parent_supplies = cs47l92_supplies, .num_parent_supplies = ARRAY_SIZE(cs47l92_supplies), }, }; const char *madera_name_from_type(enum madera_type type) { switch (type) { case CS47L15: return "CS47L15"; case CS47L35: return "CS47L35"; case CS47L85: return "CS47L85"; case CS47L90: return "CS47L90"; case CS47L91: return "CS47L91"; case CS47L92: return "CS47L92"; case CS47L93: return "CS47L93"; case WM1840: return "WM1840"; default: return "Unknown"; } } EXPORT_SYMBOL_GPL(madera_name_from_type); #define MADERA_BOOT_POLL_MAX_INTERVAL_US 5000 #define MADERA_BOOT_POLL_TIMEOUT_US 25000 static int madera_wait_for_boot(struct madera *madera) { unsigned int val; int ret; /* * We can't use an interrupt as we need to runtime resume to do so, * so we poll the status bit. This won't race with the interrupt * handler because it will be blocked on runtime resume. */ ret = regmap_read_poll_timeout(madera->regmap, MADERA_IRQ1_RAW_STATUS_1, val, (val & MADERA_BOOT_DONE_STS1), MADERA_BOOT_POLL_MAX_INTERVAL_US, MADERA_BOOT_POLL_TIMEOUT_US); if (ret) dev_err(madera->dev, "Polling BOOT_DONE_STS failed: %d\n", ret); /* * BOOT_DONE defaults to unmasked on boot so we must ack it. * Do this unconditionally to avoid interrupt storms */ regmap_write(madera->regmap, MADERA_IRQ1_STATUS_1, MADERA_BOOT_DONE_EINT1); pm_runtime_mark_last_busy(madera->dev); return ret; } static int madera_soft_reset(struct madera *madera) { int ret; ret = regmap_write(madera->regmap, MADERA_SOFTWARE_RESET, 0); if (ret != 0) { dev_err(madera->dev, "Failed to soft reset device: %d\n", ret); return ret; } /* Allow time for internal clocks to startup after reset */ usleep_range(1000, 2000); return 0; } static void madera_enable_hard_reset(struct madera *madera) { if (madera->reset_gpio) gpiod_set_value_cansleep(madera->reset_gpio, 0); } static void madera_disable_hard_reset(struct madera *madera) { if (madera->reset_gpio) { gpiod_set_value_cansleep(madera->reset_gpio, 1); usleep_range(1000, 2000); } } static int madera_dcvdd_notify(struct notifier_block *nb, unsigned long action, void *data) { struct madera *madera = container_of(nb, struct madera, dcvdd_notifier); dev_dbg(madera->dev, "DCVDD notify %lx\n", action); if (action & REGULATOR_EVENT_DISABLE) msleep(20); return NOTIFY_DONE; } #ifdef CONFIG_PM static int madera_runtime_resume(struct device *dev) { struct madera *madera = dev_get_drvdata(dev); int ret; dev_info(dev, "Leaving sleep mode\n"); ret = regulator_enable(madera->dcvdd); if (ret) { dev_err(dev, "Failed to enable DCVDD: %d\n", ret); return ret; } regcache_cache_only(madera->regmap, false); regcache_cache_only(madera->regmap_32bit, false); ret = madera_wait_for_boot(madera); if (ret) goto err; ret = regcache_sync(madera->regmap); if (ret) { dev_err(dev, "Failed to restore 16-bit register cache\n"); goto err; } ret = regcache_sync(madera->regmap_32bit); if (ret) { dev_err(dev, "Failed to restore 32-bit register cache\n"); goto err; } return 0; err: regcache_cache_only(madera->regmap_32bit, true); regcache_cache_only(madera->regmap, true); regulator_disable(madera->dcvdd); return ret; } static int madera_runtime_suspend(struct device *dev) { struct madera *madera = dev_get_drvdata(dev); dev_info(madera->dev, "Entering sleep mode\n"); regcache_cache_only(madera->regmap, true); regcache_mark_dirty(madera->regmap); regcache_cache_only(madera->regmap_32bit, true); regcache_mark_dirty(madera->regmap_32bit); regulator_disable(madera->dcvdd); return 0; } #endif const struct dev_pm_ops madera_pm_ops = { SET_RUNTIME_PM_OPS(madera_runtime_suspend, madera_runtime_resume, NULL) }; EXPORT_SYMBOL_GPL(madera_pm_ops); unsigned int madera_get_num_micbias(struct madera *madera) { switch (madera->type) { case CS47L15: return 1; case CS47L35: return 2; case CS47L85: case WM1840: return 4; case CS47L90: case CS47L91: case CS47L92: case CS47L93: return 2; default: dev_warn(madera->dev, "No micbias known for codec %s\n", madera_name_from_type(madera->type)); return 0; } } EXPORT_SYMBOL_GPL(madera_get_num_micbias); unsigned int madera_get_num_childbias(struct madera *madera, unsigned int micbias) { /* * micbias argument reserved for future codecs that don't * have the same number of children on each micbias */ switch (madera->type) { case CS47L15: return 3; case CS47L35: return 2; case CS47L85: case WM1840: return 0; case CS47L90: case CS47L91: return 4; case CS47L92: case CS47L93: switch (micbias) { case 1: return 4; case 2: return 2; default: dev_warn(madera->dev, "No child micbias for codec %s, micbias %u\n", madera_name_from_type(madera->type), micbias); return 0; } default: dev_warn(madera->dev, "No child micbias known for codec %s\n", madera_name_from_type(madera->type)); return 0; } } EXPORT_SYMBOL_GPL(madera_get_num_childbias); #ifdef CONFIG_OF const struct of_device_id madera_of_match[] = { { .compatible = "cirrus,cs47l15", .data = (void *)CS47L15 }, { .compatible = "cirrus,cs47l35", .data = (void *)CS47L35 }, { .compatible = "cirrus,cs47l85", .data = (void *)CS47L85 }, { .compatible = "cirrus,cs47l90", .data = (void *)CS47L90 }, { .compatible = "cirrus,cs47l91", .data = (void *)CS47L91 }, { .compatible = "cirrus,cs47l92", .data = (void *)CS47L92 }, { .compatible = "cirrus,cs47l93", .data = (void *)CS47L93 }, { .compatible = "cirrus,wm1840", .data = (void *)WM1840 }, {}, }; EXPORT_SYMBOL_GPL(madera_of_match); unsigned long madera_get_type_from_of(struct device *dev) { const struct of_device_id *id = of_match_device(madera_of_match, dev); if (id) return (unsigned long)id->data; else return 0; } EXPORT_SYMBOL_GPL(madera_get_type_from_of); #endif static int madera_get_reset_gpio(struct madera *madera) { int ret; /* We use 0 in pdata to indicate a GPIO has not been set */ if (dev_get_platdata(madera->dev) && (madera->pdata.reset > 0)) { /* Start out with /RESET asserted */ ret = devm_gpio_request_one(madera->dev, madera->pdata.reset, GPIOF_DIR_OUT | GPIOF_INIT_LOW, "madera reset"); if (!ret) madera->reset_gpio = gpio_to_desc(madera->pdata.reset); } else { madera->reset_gpio = devm_gpiod_get_optional(madera->dev, "reset", GPIOD_OUT_LOW); if (IS_ERR(madera->reset_gpio)) ret = PTR_ERR(madera->reset_gpio); else ret = 0; } if (ret == -EPROBE_DEFER) return ret; if (ret) { dev_err(madera->dev, "Failed to request /RESET: %d\n", ret); return ret; } if (!madera->reset_gpio) dev_warn(madera->dev, "Running without reset GPIO is not recommended\n"); return 0; } static void madera_prop_get_micbias_child(struct madera *madera, const char *name, struct madera_micbias_pin_pdata *pdata) { struct device_node *np; struct regulator_desc desc = { }; np = of_get_child_by_name(madera->dev->of_node, name); if (!np) return; desc.name = name; pdata->init_data = of_get_regulator_init_data(madera->dev, np, &desc); of_property_read_u32(np, "regulator-active-discharge", &pdata->active_discharge); } static void madera_prop_get_micbias_gen(struct madera *madera, const char *name, struct madera_micbias_pdata *pdata) { struct device_node *np; struct regulator_desc desc = { }; np = of_get_child_by_name(madera->dev->of_node, name); if (!np) return; desc.name = name; pdata->init_data = of_get_regulator_init_data(madera->dev, np, &desc); pdata->ext_cap = of_property_read_bool(np, "wlf,ext-cap"); of_property_read_u32(np, "regulator-active-discharge", &pdata->active_discharge); } static void madera_prop_get_micbias(struct madera *madera) { struct madera_micbias_pdata *pdata; char name[10]; int i, child; for (i = madera_get_num_micbias(madera) - 1; i >= 0; --i) { pdata = &madera->pdata.micbias[i]; snprintf(name, sizeof(name), "MICBIAS%d", i + 1); madera_prop_get_micbias_gen(madera, name, pdata); child = madera_get_num_childbias(madera, i + 1) - 1; for (; child >= 0; --child) { snprintf(name, sizeof(name), "MICBIAS%d%c", i + 1, 'A' + child); madera_prop_get_micbias_child(madera, name, &pdata->pin[child]); } } } static void madera_configure_micbias(struct madera *madera) { unsigned int num_micbias = madera_get_num_micbias(madera); struct madera_micbias_pdata *pdata; struct regulator_init_data *init_data; unsigned int num_child_micbias; unsigned int val, mask, reg; int i, child, ret; for (i = 0; i < num_micbias; ++i) { pdata = &madera->pdata.micbias[i]; /* Configure the child micbias pins */ val = 0; mask = 0; num_child_micbias = madera_get_num_childbias(madera, i + 1); for (child = 0; child < num_child_micbias; ++child) { if (!pdata->pin[child].init_data) continue; mask |= MADERA_MICB1A_DISCH << (child * 4); if (pdata->pin[child].active_discharge) val |= MADERA_MICB1A_DISCH << (child * 4); } if (mask) { reg = MADERA_MIC_BIAS_CTRL_5 + (i * 2); ret = regmap_update_bits(madera->regmap, reg, mask, val); if (ret) dev_warn(madera->dev, "Failed to write 0x%x (%d)\n", reg, ret); dev_dbg(madera->dev, "Set MICBIAS_CTRL%d mask=0x%x val=0x%x\n", i + 5, mask, val); } /* configure the parent */ init_data = pdata->init_data; if (!init_data) continue; mask = MADERA_MICB1_LVL_MASK | MADERA_MICB1_EXT_CAP | MADERA_MICB1_BYPASS | MADERA_MICB1_RATE; if (!init_data->constraints.max_uV) init_data->constraints.max_uV = 2800000; val = (init_data->constraints.max_uV - 1500000) / 100000; val <<= MADERA_MICB1_LVL_SHIFT; if (pdata->ext_cap) val |= MADERA_MICB1_EXT_CAP; /* if no child biases the discharge is set in the parent */ if (num_child_micbias == 0) { mask |= MADERA_MICB1_DISCH; if (pdata->active_discharge) val |= MADERA_MICB1_DISCH; } if (init_data->constraints.soft_start) val |= MADERA_MICB1_RATE; if (init_data->constraints.valid_ops_mask & REGULATOR_CHANGE_BYPASS) val |= MADERA_MICB1_BYPASS; reg = MADERA_MIC_BIAS_CTRL_1 + i; ret = regmap_update_bits(madera->regmap, reg, mask, val); if (ret) dev_warn(madera->dev, "Failed to write 0x%x (%d)\n", reg, ret); dev_dbg(madera->dev, "Set MICBIAS_CTRL%d mask=0x%x val=0x%x\n", i + 1, mask, val); } } static int madera_dev_select_pinctrl(struct madera *madera, struct pinctrl *pinctrl, const char *name) { struct pinctrl_state *pinctrl_state; int ret; pinctrl_state = pinctrl_lookup_state(pinctrl, name); /* it's ok if it doesn't exist */ if (!IS_ERR(pinctrl_state)) { dev_dbg(madera->dev, "Applying pinctrl %s state\n", name); ret = pinctrl_select_state(pinctrl, pinctrl_state); if (ret) { dev_err(madera->dev, "Failed to select pinctrl %s state: %d\n", name, ret); return ret; } } return 0; } int madera_dev_init(struct madera *madera) { struct device *dev = madera->dev; const char *name; unsigned int hwid; int (*patch_fn)(struct madera *) = NULL; const struct mfd_cell *mfd_devs; struct pinctrl *pinctrl; int n_devs = 0; int i, ret; dev_set_drvdata(madera->dev, madera); BLOCKING_INIT_NOTIFIER_HEAD(&madera->notifier); if (dev_get_platdata(madera->dev)) { memcpy(&madera->pdata, dev_get_platdata(madera->dev), sizeof(madera->pdata)); } ret = madera_get_reset_gpio(madera); if (ret) return ret; madera_prop_get_micbias(madera); regcache_cache_only(madera->regmap, true); regcache_cache_only(madera->regmap_32bit, true); for (i = 0; i < ARRAY_SIZE(madera_core_supplies); i++) madera->core_supplies[i].supply = madera_core_supplies[i]; madera->num_core_supplies = ARRAY_SIZE(madera_core_supplies); /* * Pinctrl subsystem only configures pinctrls if all referenced pins * are registered. Create our pinctrl child now so that its pins exist * otherwise external pinctrl dependencies will fail * Note: Can't devm_ because it is cleaned up after children are already * destroyed */ ret = mfd_add_devices(madera->dev, PLATFORM_DEVID_NONE, madera_pinctrl_dev, 1, NULL, 0, NULL); if (ret) { dev_err(madera->dev, "Failed to add pinctrl child: %d\n", ret); return ret; } pinctrl = pinctrl_get(dev); if (IS_ERR(pinctrl)) { ret = PTR_ERR(pinctrl); dev_err(madera->dev, "Failed to get pinctrl: %d\n", ret); goto err_pinctrl_dev; } /* Use (optional) minimal config with only external pin bindings */ ret = madera_dev_select_pinctrl(madera, pinctrl, "probe"); if (ret) goto err_pinctrl; ret = devm_regulator_bulk_get(dev, madera->num_core_supplies, madera->core_supplies); if (ret) { dev_err(dev, "Failed to request core supplies: %d\n", ret); goto err_pinctrl; } switch (madera->type) { case CS47L15: madera->reset_errata = true; break; case CS47L35: case CS47L90: case CS47L91: case CS47L92: case CS47L93: break; case CS47L85: case WM1840: /* On these DCVDD could be supplied from the onboard LDO1 */ ret = mfd_add_devices(madera->dev, PLATFORM_DEVID_NONE, madera_ldo1_devs, ARRAY_SIZE(madera_ldo1_devs), NULL, 0, NULL); if (ret) { dev_err(dev, "Failed to add LDO1 child: %d\n", ret); goto err_pinctrl; } break; default: dev_err(madera->dev, "Unknown device type %d\n", madera->type); ret = -ENODEV; goto err_pinctrl; } /* * Don't use devres here because the only device we have to get * against is the MFD device and DCVDD will likely be supplied by * one of its children. Meaning that the regulator will be * destroyed by the time devres calls regulator put. */ madera->dcvdd = regulator_get(madera->dev, "DCVDD"); if (IS_ERR(madera->dcvdd)) { ret = PTR_ERR(madera->dcvdd); dev_err(dev, "Failed to request DCVDD: %d\n", ret); goto err_pinctrl; } madera->dcvdd_notifier.notifier_call = madera_dcvdd_notify; ret = regulator_register_notifier(madera->dcvdd, &madera->dcvdd_notifier); if (ret) { dev_err(dev, "Failed to register DCVDD notifier %d\n", ret); goto err_dcvdd; } /* Ensure period of reset asserted before we apply the supplies */ msleep(20); ret = regulator_bulk_enable(madera->num_core_supplies, madera->core_supplies); if (ret) { dev_err(dev, "Failed to enable core supplies: %d\n", ret); goto err_notifier; } if (madera->reset_errata) madera_disable_hard_reset(madera); ret = regulator_enable(madera->dcvdd); if (ret) { dev_err(dev, "Failed to enable DCVDD: %d\n", ret); goto err_enable; } if (madera->reset_errata) usleep_range(ERRATA_DCVDD_MIN_US, ERRATA_DCVDD_MAX_US); else madera_disable_hard_reset(madera); regcache_cache_only(madera->regmap, false); regcache_cache_only(madera->regmap_32bit, false); /* * Verify that this is a chip we know about before we * starting doing any writes to its registers */ ret = regmap_read(madera->regmap, MADERA_SOFTWARE_RESET, &hwid); if (ret) { dev_err(dev, "Failed to read ID register: %d\n", ret); goto err_reset; } switch (hwid) { case CS47L15_SILICON_ID: case CS47L35_SILICON_ID: case CS47L85_SILICON_ID: case CS47L90_SILICON_ID: case CS47L92_SILICON_ID: break; default: dev_err(madera->dev, "Unknown device ID: %x\n", hwid); ret = -EINVAL; goto err_reset; } /* If we don't have a reset GPIO use a soft reset */ if (!madera->reset_gpio || madera->reset_errata) { ret = madera_soft_reset(madera); if (ret) goto err_reset; } ret = madera_wait_for_boot(madera); if (ret) { dev_err(madera->dev, "Device failed initial boot: %d\n", ret); goto err_reset; } ret = regmap_read(madera->regmap, MADERA_HARDWARE_REVISION, &madera->rev); if (ret) { dev_err(dev, "Failed to read revision register: %d\n", ret); goto err_reset; } madera->rev &= MADERA_HW_REVISION_MASK; name = madera_name_from_type(madera->type); switch (hwid) { case CS47L15_SILICON_ID: if (IS_ENABLED(CONFIG_MFD_CS47L15)) { switch (madera->type) { case CS47L15: patch_fn = cs47l15_patch; mfd_devs = cs47l15_devs; n_devs = ARRAY_SIZE(cs47l15_devs); break; default: break; } } break; case CS47L35_SILICON_ID: if (IS_ENABLED(CONFIG_MFD_CS47L35)) { switch (madera->type) { case CS47L35: patch_fn = cs47l35_patch; mfd_devs = cs47l35_devs; n_devs = ARRAY_SIZE(cs47l35_devs); break; default: break; } } break; case CS47L85_SILICON_ID: if (IS_ENABLED(CONFIG_MFD_CS47L85)) { switch (madera->type) { case CS47L85: case WM1840: patch_fn = cs47l85_patch; mfd_devs = cs47l85_devs; n_devs = ARRAY_SIZE(cs47l85_devs); break; default: break; } } break; case CS47L90_SILICON_ID: if (IS_ENABLED(CONFIG_MFD_CS47L90)) { switch (madera->type) { case CS47L90: case CS47L91: patch_fn = cs47l90_patch; mfd_devs = cs47l90_devs; n_devs = ARRAY_SIZE(cs47l90_devs); break; default: break; } } break; case CS47L92_SILICON_ID: if (IS_ENABLED(CONFIG_MFD_CS47L92)) { switch (madera->type) { case CS47L92: case CS47L93: patch_fn = cs47l92_patch; mfd_devs = cs47l92_devs; n_devs = ARRAY_SIZE(cs47l92_devs); break; default: break; } } break; default: break; } if (!n_devs) { dev_err(madera->dev, "Device ID 0x%x not a %s\n", hwid, name); ret = -ENODEV; goto err_reset; } dev_info(dev, "%s silicon revision %d\n", name, madera->rev); /* Apply hardware patch */ if (patch_fn) { ret = patch_fn(madera); if (ret) { dev_err(madera->dev, "Failed to apply patch %d\n", ret); goto err_reset; } } /* Apply (optional) main pinctrl config, this will configure our pins */ ret = madera_dev_select_pinctrl(madera, pinctrl, "active"); if (ret) goto err_reset; /* Init 32k clock sourced from MCLK2 */ ret = regmap_update_bits(madera->regmap, MADERA_CLOCK_32K_1, MADERA_CLK_32K_ENA_MASK | MADERA_CLK_32K_SRC_MASK, MADERA_CLK_32K_ENA | MADERA_32KZ_MCLK2); if (ret) { dev_err(madera->dev, "Failed to init 32k clock: %d\n", ret); goto err_reset; } madera_configure_micbias(madera); pm_runtime_set_active(madera->dev); pm_runtime_enable(madera->dev); pm_runtime_set_autosuspend_delay(madera->dev, 100); pm_runtime_use_autosuspend(madera->dev); ret = mfd_add_devices(madera->dev, PLATFORM_DEVID_NONE, mfd_devs, n_devs, NULL, 0, NULL); if (ret) { dev_err(madera->dev, "Failed to add subdevices: %d\n", ret); goto err_pm_runtime; } pinctrl_put(pinctrl); return 0; err_pm_runtime: pm_runtime_disable(madera->dev); err_reset: madera_enable_hard_reset(madera); regulator_disable(madera->dcvdd); err_enable: regulator_bulk_disable(madera->num_core_supplies, madera->core_supplies); err_notifier: regulator_unregister_notifier(madera->dcvdd, &madera->dcvdd_notifier); err_dcvdd: regulator_put(madera->dcvdd); err_pinctrl: pinctrl_put(pinctrl); err_pinctrl_dev: mfd_remove_devices(dev); return ret; } EXPORT_SYMBOL_GPL(madera_dev_init); int madera_dev_exit(struct madera *madera) { /* Prevent any IRQs being serviced while we clean up */ disable_irq(madera->irq); /* * DCVDD could be supplied by a child node, we must disable it before * removing the children, and prevent PM runtime from turning it back on */ pm_runtime_disable(madera->dev); regulator_disable(madera->dcvdd); regulator_unregister_notifier(madera->dcvdd, &madera->dcvdd_notifier); regulator_put(madera->dcvdd); mfd_remove_devices(madera->dev); madera_enable_hard_reset(madera); regulator_bulk_disable(madera->num_core_supplies, madera->core_supplies); return 0; } EXPORT_SYMBOL_GPL(madera_dev_exit);