// SPDX-License-Identifier: GPL-2.0 // // Copyright (C) 2021 ROHM Semiconductors // regulator IRQ based event notification helpers // // Logic has been partially adapted from qcom-labibb driver. // // Author: Matti Vaittinen #include #include #include #include #include #include #include #include #include #include "internal.h" #define REGULATOR_FORCED_SAFETY_SHUTDOWN_WAIT_MS 10000 struct regulator_irq { struct regulator_irq_data rdata; struct regulator_irq_desc desc; int irq; int retry_cnt; struct delayed_work isr_work; }; /* * Should only be called from threaded handler to prevent potential deadlock */ static void rdev_flag_err(struct regulator_dev *rdev, int err) { spin_lock(&rdev->err_lock); rdev->cached_err |= err; spin_unlock(&rdev->err_lock); } static void rdev_clear_err(struct regulator_dev *rdev, int err) { spin_lock(&rdev->err_lock); rdev->cached_err &= ~err; spin_unlock(&rdev->err_lock); } static void regulator_notifier_isr_work(struct work_struct *work) { struct regulator_irq *h; struct regulator_irq_desc *d; struct regulator_irq_data *rid; int ret = 0; int tmo, i; int num_rdevs; h = container_of(work, struct regulator_irq, isr_work.work); d = &h->desc; rid = &h->rdata; num_rdevs = rid->num_states; reread: if (d->fatal_cnt && h->retry_cnt > d->fatal_cnt) { if (!d->die) return hw_protection_shutdown("Regulator HW failure? - no IC recovery", REGULATOR_FORCED_SAFETY_SHUTDOWN_WAIT_MS); ret = d->die(rid); /* * If the 'last resort' IC recovery failed we will have * nothing else left to do... */ if (ret) return hw_protection_shutdown("Regulator HW failure. IC recovery failed", REGULATOR_FORCED_SAFETY_SHUTDOWN_WAIT_MS); /* * If h->die() was implemented we assume recovery has been * attempted (probably regulator was shut down) and we * just enable IRQ and bail-out. */ goto enable_out; } if (d->renable) { ret = d->renable(rid); if (ret == REGULATOR_FAILED_RETRY) { /* Driver could not get current status */ h->retry_cnt++; if (!d->reread_ms) goto reread; tmo = d->reread_ms; goto reschedule; } if (ret) { /* * IC status reading succeeded. update error info * just in case the renable changed it. */ for (i = 0; i < num_rdevs; i++) { struct regulator_err_state *stat; struct regulator_dev *rdev; stat = &rid->states[i]; rdev = stat->rdev; rdev_clear_err(rdev, (~stat->errors) & stat->possible_errs); } h->retry_cnt++; /* * The IC indicated problem is still ON - no point in * re-enabling the IRQ. Retry later. */ tmo = d->irq_off_ms; goto reschedule; } } /* * Either IC reported problem cleared or no status checker was provided. * If problems are gone - good. If not - then the IRQ will fire again * and we'll have a new nice loop. In any case we should clear error * flags here and re-enable IRQs. */ for (i = 0; i < num_rdevs; i++) { struct regulator_err_state *stat; struct regulator_dev *rdev; stat = &rid->states[i]; rdev = stat->rdev; rdev_clear_err(rdev, stat->possible_errs); } /* * Things have been seemingly successful => zero retry-counter. */ h->retry_cnt = 0; enable_out: enable_irq(h->irq); return; reschedule: if (!d->high_prio) mod_delayed_work(system_wq, &h->isr_work, msecs_to_jiffies(tmo)); else mod_delayed_work(system_highpri_wq, &h->isr_work, msecs_to_jiffies(tmo)); } static irqreturn_t regulator_notifier_isr(int irq, void *data) { struct regulator_irq *h = data; struct regulator_irq_desc *d; struct regulator_irq_data *rid; unsigned long rdev_map = 0; int num_rdevs; int ret, i; d = &h->desc; rid = &h->rdata; num_rdevs = rid->num_states; if (d->fatal_cnt) h->retry_cnt++; /* * we spare a few cycles by not clearing statuses prior to this call. * The IC driver must initialize the status buffers for rdevs * which it indicates having active events via rdev_map. * * Maybe we should just to be on a safer side(?) */ ret = d->map_event(irq, rid, &rdev_map); /* * If status reading fails (which is unlikely) we don't ack/disable * IRQ but just increase fail count and retry when IRQ fires again. * If retry_count exceeds the given safety limit we call IC specific die * handler which can try disabling regulator(s). * * If no die handler is given we will just bug() as a last resort. * * We could try disabling all associated rdevs - but we might shoot * ourselves in the head and leave the problematic regulator enabled. So * if IC has no die-handler populated we just assume the regulator * can't be disabled. */ if (unlikely(ret == REGULATOR_FAILED_RETRY)) goto fail_out; h->retry_cnt = 0; /* * Let's not disable IRQ if there were no status bits for us. We'd * better leave spurious IRQ handling to genirq */ if (ret || !rdev_map) return IRQ_NONE; /* * Some events are bogus if the regulator is disabled. Skip such events * if all relevant regulators are disabled */ if (d->skip_off) { for_each_set_bit(i, &rdev_map, num_rdevs) { struct regulator_dev *rdev; const struct regulator_ops *ops; rdev = rid->states[i].rdev; ops = rdev->desc->ops; /* * If any of the flagged regulators is enabled we do * handle this */ if (ops->is_enabled(rdev)) break; } if (i == num_rdevs) return IRQ_NONE; } /* Disable IRQ if HW keeps line asserted */ if (d->irq_off_ms) disable_irq_nosync(irq); /* * IRQ seems to be for us. Let's fire correct notifiers / store error * flags */ for_each_set_bit(i, &rdev_map, num_rdevs) { struct regulator_err_state *stat; struct regulator_dev *rdev; stat = &rid->states[i]; rdev = stat->rdev; rdev_dbg(rdev, "Sending regulator notification EVT 0x%lx\n", stat->notifs); regulator_notifier_call_chain(rdev, stat->notifs, NULL); rdev_flag_err(rdev, stat->errors); } if (d->irq_off_ms) { if (!d->high_prio) schedule_delayed_work(&h->isr_work, msecs_to_jiffies(d->irq_off_ms)); else mod_delayed_work(system_highpri_wq, &h->isr_work, msecs_to_jiffies(d->irq_off_ms)); } return IRQ_HANDLED; fail_out: if (d->fatal_cnt && h->retry_cnt > d->fatal_cnt) { /* If we have no recovery, just try shut down straight away */ if (!d->die) { hw_protection_shutdown("Regulator failure. Retry count exceeded", REGULATOR_FORCED_SAFETY_SHUTDOWN_WAIT_MS); } else { ret = d->die(rid); /* If die() failed shut down as a last attempt to save the HW */ if (ret) hw_protection_shutdown("Regulator failure. Recovery failed", REGULATOR_FORCED_SAFETY_SHUTDOWN_WAIT_MS); } } return IRQ_NONE; } static int init_rdev_state(struct device *dev, struct regulator_irq *h, struct regulator_dev **rdev, int common_err, int *rdev_err, int rdev_amount) { int i; h->rdata.states = devm_kzalloc(dev, sizeof(*h->rdata.states) * rdev_amount, GFP_KERNEL); if (!h->rdata.states) return -ENOMEM; h->rdata.num_states = rdev_amount; h->rdata.data = h->desc.data; for (i = 0; i < rdev_amount; i++) { h->rdata.states[i].possible_errs = common_err; if (rdev_err) h->rdata.states[i].possible_errs |= *rdev_err++; h->rdata.states[i].rdev = *rdev++; } return 0; } static void init_rdev_errors(struct regulator_irq *h) { int i; for (i = 0; i < h->rdata.num_states; i++) if (h->rdata.states[i].possible_errs) h->rdata.states[i].rdev->use_cached_err = true; } /** * regulator_irq_helper - register IRQ based regulator event/error notifier * * @dev: device providing the IRQs * @d: IRQ helper descriptor. * @irq: IRQ used to inform events/errors to be notified. * @irq_flags: Extra IRQ flags to be OR'ed with the default * IRQF_ONESHOT when requesting the (threaded) irq. * @common_errs: Errors which can be flagged by this IRQ for all rdevs. * When IRQ is re-enabled these errors will be cleared * from all associated regulators * @per_rdev_errs: Optional error flag array describing errors specific * for only some of the regulators. These errors will be * or'ed with common errors. If this is given the array * should contain rdev_amount flags. Can be set to NULL * if there is no regulator specific error flags for this * IRQ. * @rdev: Array of pointers to regulators associated with this * IRQ. * @rdev_amount: Amount of regulators associated with this IRQ. * * Return: handle to irq_helper or an ERR_PTR() encoded error code. */ void *regulator_irq_helper(struct device *dev, const struct regulator_irq_desc *d, int irq, int irq_flags, int common_errs, int *per_rdev_errs, struct regulator_dev **rdev, int rdev_amount) { struct regulator_irq *h; int ret; if (!rdev_amount || !d || !d->map_event || !d->name) return ERR_PTR(-EINVAL); h = devm_kzalloc(dev, sizeof(*h), GFP_KERNEL); if (!h) return ERR_PTR(-ENOMEM); h->irq = irq; h->desc = *d; ret = init_rdev_state(dev, h, rdev, common_errs, per_rdev_errs, rdev_amount); if (ret) return ERR_PTR(ret); init_rdev_errors(h); if (h->desc.irq_off_ms) INIT_DELAYED_WORK(&h->isr_work, regulator_notifier_isr_work); ret = request_threaded_irq(h->irq, NULL, regulator_notifier_isr, IRQF_ONESHOT | irq_flags, h->desc.name, h); if (ret) { dev_err(dev, "Failed to request IRQ %d\n", irq); return ERR_PTR(ret); } return h; } EXPORT_SYMBOL_GPL(regulator_irq_helper); /** * regulator_irq_helper_cancel - drop IRQ based regulator event/error notifier * * @handle: Pointer to handle returned by a successful call to * regulator_irq_helper(). Will be NULLed upon return. * * The associated IRQ is released and work is cancelled when the function * returns. */ void regulator_irq_helper_cancel(void **handle) { if (handle && *handle) { struct regulator_irq *h = *handle; free_irq(h->irq, h); if (h->desc.irq_off_ms) cancel_delayed_work_sync(&h->isr_work); h = NULL; } } EXPORT_SYMBOL_GPL(regulator_irq_helper_cancel);