/**
* pm_qos_remove_notifier - deletes notification entry from chain.
* @pm_qos_class: identifies which qos target changes are notified.
* @notifier: notifier block to be removed.
*
* will remove the notifier from the notification chain that gets called
* upon changes to the pm_qos_class target value.
*/
int pm_qos_remove_notifier(int pm_qos_class, struct notifier_block *notifier)
{
int retval;
retval = blocking_notifier_chain_unregister(
pm_qos_array[pm_qos_class]->constraints->notifiers,
notifier);
return retval;
}
static int hdmi_remove(struct snd_soc_codec *codec)
{
struct hdmi_codec_data *priv = snd_soc_codec_get_drvdata(codec);
blocking_notifier_chain_unregister(&priv->dssdev->state_notifiers,
&priv->notifier);
iounmap(priv->ip_data.base_wp);
kfree(priv);
return 0;
}
int adp5520_unregister_notifier(struct device *dev, struct notifier_block *nb,
unsigned int events)
{
struct adp5520_chip *chip = dev_get_drvdata(dev);
adp5520_clr_bits(chip->dev, ADP5520_INTERRUPT_ENABLE,
events & (ADP5520_KP_IEN | ADP5520_KR_IEN |
ADP5520_OVP_IEN | ADP5520_CMPR_IEN));
return blocking_notifier_chain_unregister(&chip->notifier_list, nb);
}
int axp_unregister_notifier(struct device *dev, struct notifier_block *nb,
uint64_t irqs)
{
struct axp_dev *chip = dev_get_drvdata(dev);
chip->ops->disable_irqs(chip, irqs);
if(NULL != nb) {
return blocking_notifier_chain_unregister(&chip->notifier_list, nb);
}
return 0;
}
int muic_notifier_unregister(struct notifier_block *nb)
{
int ret = 0;
printk(KERN_DEBUG "[muic] %s: listener=%d unregister\n", __func__, nb->priority);
ret = blocking_notifier_chain_unregister(&(muic_notifier.notifier_call_chain), nb);
if (ret < 0)
printk(KERN_ERR "[muic] notifier_chain_unregister error(%d)\n", ret);
DESTROY_MUIC_NOTIFIER_BLOCK(nb);
return ret;
}
int axp_unregister_notifier(struct device *dev, struct notifier_block *nb,
uint64_t irqs)
{
struct axp_dev *chip = dev_get_drvdata(dev);
#ifdef CONFIG_SUNXI_ARISC
arisc_disable_nmi_irq();
#else
#endif
chip->ops->disable_irqs(chip, irqs);
if(NULL != nb) {
return blocking_notifier_chain_unregister(&chip->notifier_list, nb);
}
return 0;
}
void put_otg_notify(struct otg_notify *n)
{
if (n->booting_delay_sec)
cancel_delayed_work_sync(&u_notify->b_delay.booting_work);
if (n->is_wakelock)
wake_lock_destroy(&u_notify->wlock);
if (gpio_is_valid(n->vbus_detect_gpio))
free_irq(gpio_to_irq(n->vbus_detect_gpio), NULL);
host_notify_dev_unregister(&u_notify->ndev);
blocking_notifier_chain_unregister(&u_notify->o_notify->extra_notifier,
&u_notify->extra_nb);
atomic_notifier_chain_unregister(&u_notify->o_notify->otg_notifier,
&u_notify->otg_nb);
u_notify->o_notify = NULL;
}
static int cros_ec_rtc_remove(struct platform_device *pdev)
{
struct cros_ec_rtc *cros_ec_rtc = platform_get_drvdata(pdev);
struct device *dev = &pdev->dev;
int ret;
ret = blocking_notifier_chain_unregister(
&cros_ec_rtc->cros_ec->event_notifier,
&cros_ec_rtc->notifier);
if (ret) {
dev_err(dev, "failed to unregister notifier\n");
return ret;
}
return 0;
}
static void nvhost_pod_exit(struct devfreq *df)
{
struct podgov_info_rec *podgov = df->data;
struct platform_device *d = to_platform_device(df->dev.parent);
blocking_notifier_chain_unregister(&throughput_notifier_list,
&podgov->throughput_hint_notifier);
cancel_delayed_work(&podgov->idle_timer);
device_remove_file(&d->dev, &dev_attr_enable_3d_scaling);
device_remove_file(&d->dev, &dev_attr_user);
device_remove_file(&d->dev, &dev_attr_freq_request);
nvhost_scale3d_debug_deinit(df);
kfree(podgov);
}
int mmi_hall_unregister_notifier(struct notifier_block *nb,
unsigned long stype)
{
int error;
struct mmi_hall_data *mdata = stml0xx_misc_data->hall_data;
if (!mdata)
return -ENODEV;
error = blocking_notifier_chain_unregister(&mdata->nhead[stype], nb);
pr_debug("%s: hall sensor %lu notifier unregister\n", __func__, stype);
if (!mdata->nhead[stype].head) {
mdata->enabled &= ~(1 << stype);
pr_debug("%s: hall sensor %lu no clients\n", __func__, stype);
}
return error;
}
int uh_unregister_notifier(struct notifier_block *n)
{
struct uh_data *uh = g_puh_data;
int rv;
D("Unregister notifier: 0x%p.\n", (void *)n);
/* Wait all stop. */
uh_disable();
rv = blocking_notifier_chain_unregister(&uh->notifier_head, n);
uh_enable();
uh_start_work(uh, DO_DETECT); /* Update status. */
return rv;
}EXPORT_SYMBOL(uh_unregister_notifier);
/*
* Remove a previously registered callback.
*/
int ab3100_event_unregister(struct ab3100 *ab3100,
struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&ab3100->event_subscribers,
nb);
}
int unregister_notifier_by_touchkey(struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&touchkey_notifier_list, nb);
}
void mdp3_ctrl_notifier_unregister(struct mdp3_session_data *ses,
struct notifier_block *notifier)
{
blocking_notifier_chain_unregister(&ses->notifier_head, notifier);
}
/**
* ubi_unregister_volume_notifier - unregister the volume notifier.
* @nb: the notifier description object
*
* This function unregisters volume notifier @nm and returns zero in case of
* success and a negative error code in case of failure.
*/
int ubi_unregister_volume_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&ubi_notifiers, nb);
}
/**
* usb_unregister_notify - unregister a notifier callback
* @nb: pointer to the notifier block for the callback events.
*
* usb_register_notify() must have been previously called for this function
* to work properly.
*/
void usb_unregister_notify(struct notifier_block *nb)
{
blocking_notifier_chain_unregister(&usb_notifier_list, nb);
}
int unregister_thermal_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&thermal_chain_head, nb);
}
int unregister_inetaddr_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
}
int acc_unregister_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&acc_mhl_notifier, nb);
}
void omap_mbox_put(struct omap_mbox *mbox, struct notifier_block *nb)
{
blocking_notifier_chain_unregister(&mbox->notifier, nb);
omap_mbox_fini(mbox);
}
void unregister_memory_notifier(struct notifier_block *nb)
{
blocking_notifier_chain_unregister(&memory_chain, nb);
}
void unregister_xenstore_notifier(struct notifier_block *nb)
{
blocking_notifier_chain_unregister(&xenstore_chain, nb);
}
int bus_unregister_notifier(struct bus_type *bus, struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&bus->p->bus_notifier, nb);
}
int wcd9xxx_resmgr_unregister_notifier(struct wcd9xxx_resmgr *resmgr,
struct notifier_block *nblock)
{
return blocking_notifier_chain_unregister(&resmgr->notifier, nblock);
}
void rpc_pipefs_notifier_unregister(struct notifier_block *nb)
{
blocking_notifier_chain_unregister(&rpc_pipefs_notifier_list, nb);
}
int exynos_cpufreq_smpl_warn_unregister_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&exynos_cpufreq_smpl_warn_notifier_list, nb);
}
int unregister_notifier_by_psensor(struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&psensor_notifier_list, nb);
}
int unregister_capictr_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&ctr_notifier_list, nb);
}
int unregister_pm_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&pm_chain_head, nb);
}
/**
* unregister_reboot_notifier - Unregister previously registered reboot notifier
* @nb: Hook to be unregistered
*
* Unregisters a previously registered reboot
* notifier function.
*
* Returns zero on success, or %-ENOENT on failure.
*/
int unregister_reboot_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&reboot_notifier_list, nb);
}
