void cpufreq_stats_reset(void) { unsigned int cpu; cpufreq_unregister_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); cpufreq_unregister_notifier(¬ifier_trans_block, CPUFREQ_TRANSITION_NOTIFIER); unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier); for_each_online_cpu(cpu) { cpufreq_stats_free_sysfs(cpu); cpufreq_stats_free_table(cpu); } cpufreq_register_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); cpufreq_register_notifier(¬ifier_trans_block, CPUFREQ_TRANSITION_NOTIFIER); register_hotcpu_notifier(&cpufreq_stat_cpu_notifier); for_each_online_cpu(cpu) { cpufreq_update_policy(cpu); } return; }
static void __exit cpufreq_stats_exit(void) { unsigned int cpu; cpufreq_unregister_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); cpufreq_unregister_notifier(¬ifier_trans_block, CPUFREQ_TRANSITION_NOTIFIER); for_each_online_cpu(cpu) cpufreq_stats_free_table(cpu); }
static void __exit cpufreq_stats_exit(void) { unsigned int cpu; cpufreq_unregister_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); cpufreq_unregister_notifier(¬ifier_trans_block, CPUFREQ_TRANSITION_NOTIFIER); unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier); for_each_online_cpu(cpu) { cpufreq_stat_cpu_callback(&cpufreq_stat_cpu_notifier, CPU_DEAD, (void *)(long)cpu); } }
static void cpufreq_stats_cleanup(void) { unsigned int cpu; cpufreq_unregister_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); cpufreq_unregister_notifier(¬ifier_trans_block, CPUFREQ_TRANSITION_NOTIFIER); unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier); for_each_online_cpu(cpu) { cpufreq_stats_free_table(cpu); cpufreq_stats_free_sysfs(cpu); } cpufreq_allstats_free(); }
static int __init cpufreq_stats_init(void) { int ret; unsigned int cpu; spin_lock_init(&cpufreq_stats_lock); ret = cpufreq_register_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); if (ret) return ret; ret = cpufreq_register_notifier(¬ifier_trans_block, CPUFREQ_TRANSITION_NOTIFIER); if (ret) { cpufreq_unregister_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); return ret; } register_hotcpu_notifier(&cpufreq_stat_cpu_notifier); for_each_online_cpu(cpu) { cpufreq_update_policy(cpu); } create_all_freq_table(); ret = sysfs_create_file(cpufreq_global_kobject, &_attr_all_time_in_state.attr); if (ret) pr_warn("Error creating sysfs file for cpufreq stats\n"); return 0; }
static int __init cpufreq_stats_init(void) { int ret; unsigned int cpu; spin_lock_init(&cpufreq_stats_lock); ret = cpufreq_register_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); if (ret) return ret; ret = cpufreq_register_notifier(¬ifier_trans_block, CPUFREQ_TRANSITION_NOTIFIER); if (ret) { cpufreq_unregister_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); return ret; } register_hotcpu_notifier(&cpufreq_stat_cpu_notifier); for_each_online_cpu(cpu) { cpufreq_update_policy(cpu); } ret = sysfs_create_group(cpufreq_global_kobject, &overall_stats_attr_group); return 0; }
static int __init cpufreq_stats_init(void) { int ret; unsigned int cpu; spin_lock_init(&cpufreq_stats_lock); if ((ret = cpufreq_register_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER))) return ret; if ((ret = cpufreq_register_notifier(¬ifier_trans_block, CPUFREQ_TRANSITION_NOTIFIER))) { cpufreq_unregister_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); return ret; } register_hotcpu_notifier(&cpufreq_stat_cpu_notifier); for_each_online_cpu(cpu) { cpufreq_stat_cpu_callback(&cpufreq_stat_cpu_notifier, CPU_ONLINE, (void *)(long)cpu); } return 0; }
static int __init cpufreq_stats_init(void) { int ret; unsigned int cpu; spin_lock_init(&cpufreq_stats_lock); ret = cpufreq_register_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); if (ret) return ret; for_each_online_cpu(cpu) cpufreq_stats_create_table(cpu); ret = cpufreq_register_notifier(¬ifier_trans_block, CPUFREQ_TRANSITION_NOTIFIER); if (ret) { cpufreq_unregister_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); for_each_online_cpu(cpu) cpufreq_stats_free_table(cpu); return ret; } create_all_freq_table(); ret = cpufreq_sysfs_create_file(&_attr_all_time_in_state.attr); if (ret) pr_warn("Cannot create sysfs file for cpufreq stats\n"); ret = cpufreq_sysfs_create_file(&_attr_current_in_state.attr); if (ret) pr_warn("Cannot create sysfs file for cpufreq current stats\n"); return 0; }
static int __init cpufreq_stats_init(void) { int ret; unsigned int cpu; spin_lock_init(&cpufreq_stats_lock); ret = cpufreq_register_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); if (ret) return ret; register_hotcpu_notifier(&cpufreq_stat_cpu_notifier); for_each_online_cpu(cpu) cpufreq_update_policy(cpu); ret = cpufreq_register_notifier(¬ifier_trans_block, CPUFREQ_TRANSITION_NOTIFIER); if (ret) { cpufreq_unregister_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier); for_each_online_cpu(cpu) cpufreq_stats_free_table(cpu); return ret; } return 0; }
void thermal_freq_register_unregister(struct thermal_freq *therm) { cpufreq_unregister_notifier(&thermal_cpufreq_notifier_block, CPUFREQ_POLICY_NOTIFIER); thermal_zone_device_unregister(therm->tdev); thermal_cooling_device_unregister(therm->cdev); kzfree(therm); }
static inline void s3c2410wdt_cpufreq_deregister(void) { if (soc_is_exynos5250()) return; cpufreq_unregister_notifier(&s3c2410wdt_cpufreq_transition_nb, CPUFREQ_TRANSITION_NOTIFIER); }
static int ls1x_cpufreq_remove(struct platform_device *pdev) { cpufreq_unregister_notifier(&ls1x_cpufreq_notifier_block, CPUFREQ_TRANSITION_NOTIFIER); cpufreq_unregister_driver(&ls1x_cpufreq_driver); return 0; }
void acpi_processor_ppc_exit(void) { if (acpi_processor_ppc_status & PPC_REGISTERED) cpufreq_unregister_notifier(&acpi_ppc_notifier_block, CPUFREQ_POLICY_NOTIFIER); acpi_processor_ppc_status &= ~PPC_REGISTERED; }
static void cs_exit(struct dbs_data *dbs_data, bool notify) { if (notify) cpufreq_unregister_notifier(&cs_cpufreq_notifier_block, CPUFREQ_TRANSITION_NOTIFIER); kfree(dbs_data->tuners); }
static inline void mfc_cpufreq_deregister(void) { clk_put(bus_clk); prev_bus_rate = 0; cpufreq_unregister_notifier(&pm->freq_transition, CPUFREQ_TRANSITION_NOTIFIER); }
void acpi_thermal_cpufreq_exit(void) { if (acpi_thermal_cpufreq_is_init) cpufreq_unregister_notifier (&acpi_thermal_cpufreq_notifier_block, CPUFREQ_POLICY_NOTIFIER); acpi_thermal_cpufreq_is_init = 0; }
static void __exit cpufreq_exit(void) { if (!nowait && saved_cpu_wait) cpu_wait = saved_cpu_wait; cpufreq_unregister_driver(&loongson2_cpufreq_driver); cpufreq_unregister_notifier(&loongson2_cpufreq_notifier_block, CPUFREQ_TRANSITION_NOTIFIER); platform_driver_unregister(&platform_driver); }
static int __init msm_sleep_info_init(void) { int err = 0; int cpu; struct sleep_data *sleep_info = NULL; msm_stats_wq = create_workqueue("msm_stats_wq"); if (!msm_stats_wq) { printk(KERN_ERR "Creation of msm_stats_wq failed!!\n"); return -EINVAL; } /* Register callback from idle for all cpus */ msm_idle_register_cb(idle_enter, idle_exit); INIT_DELAYED_WORK_DEFERRABLE(&rq_info.rq_work, rq_work_fn); INIT_DELAYED_WORK_DEFERRABLE(&rq_info.def_timer_work, def_work_fn); init_rq_attribs(); for_each_possible_cpu(cpu) { printk(KERN_INFO "msm_sleep_stats: Initializing sleep stats " "for CPU[%d]\n", cpu); sleep_info = &per_cpu(core_sleep_info, cpu); sleep_info->cpu = cpu; INIT_WORK(&sleep_info->work, notify_uspace_work_fn); /* Initialize high resolution timer */ hrtimer_init(&sleep_info->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); sleep_info->timer.function = timer_func; /* Register for cpufreq policy changes */ sleep_info->nb.notifier_call = policy_change_notifier; err = cpufreq_register_notifier(&sleep_info->nb, CPUFREQ_POLICY_NOTIFIER); if (err) goto cleanup; /* Create sysfs object */ err = add_sysfs_objects(sleep_info); if (err) goto cleanup; continue; cleanup: printk(KERN_INFO "msm_sleep_stats: Failed to initialize sleep " "stats for CPU[%d]\n", cpu); sleep_info->cpu = -1; cpufreq_unregister_notifier(&sleep_info->nb, CPUFREQ_POLICY_NOTIFIER); remove_sysfs_objects(sleep_info); } return 0; }
/* pxa_pcmcia_driver_shutdown() * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ * Invokes the low-level kernel service to free IRQs associated with this * socket controller and reset GPIO edge detection. */ static void __exit pxa_pcmcia_driver_shutdown(void){ del_timer_sync(&poll_timer); unregister_ss_entry(&pxa_pcmcia_operations); #ifdef CONFIG_CPU_FREQ cpufreq_unregister_notifier(&pxa_pcmcia_notifier_block); #endif pcmcia_low_level->shutdown(); flush_scheduled_tasks(); DEBUG(1, "pxa_cs: shutdown complete\n"); }
static int s3c_sdi_remove(struct device *dev) { struct platform_device* pdev = to_platform_device(dev); struct mmc_host *mmc = platform_get_drvdata(pdev); struct s3c_sdi_host *host = mmc_priv(mmc); #if defined CONFIG_CPU_FREQ && defined CONFIG_S3C24XX_DFS_CPUFREQ cpufreq_unregister_notifier(&host->freq_transition, CPUFREQ_TRANSITION_NOTIFIER); cpufreq_unregister_notifier(&host->freq_policy, CPUFREQ_POLICY_NOTIFIER); #endif del_timer_sync(&host->timer); mmc_remove_host(mmc); clk_disable(host->clk); clk_put(host->clk); free_irq(host->irq_cd, host); free_irq(host->irq, host); mmc_free_host(mmc); return 0; }
static int ltc3577_detach( struct i2c_client *c ) { #if defined CONFIG_CPU_FREQ && (defined CONFIG_S3C24XX_DVS_CPUFREQ || defined S3C24XX_DFS_CPUFREQ) struct ltc3577_i2c_driver *driver=(struct ltc3577_i2c_driver *) container_of( c, struct ltc3577_i2c_driver, client ); #endif /* First unregister the I2C client's members. */ if( IO_HaveUsbBusPowered() ) { if( remove_usb_state_change_listener( ltc3577_state_change_listener, NULL ) != 0 ) printk( KERN_ERR "LTC3577: Couldn't unregister USBMODE change state listener!\n" ); } #if defined CONFIG_CPU_FREQ && (defined CONFIG_S3C24XX_DVS_CPUFREQ || defined S3C24XX_DFS_CPUFREQ) /* Unregister CPU frequency scaling. */ cpufreq_unregister_notifier( &driver->freq_transition, CPUFREQ_TRANSITION_NOTIFIER ); cpufreq_unregister_notifier( &driver->freq_policy, CPUFREQ_POLICY_NOTIFIER ); #endif /* Now remove the I2C client. */ i2c_detach_client(c); return 0; }
static int osiris_dvs_remove(struct platform_device *pdev) { dev_info(&pdev->dev, "exiting\n"); /* disable any current dvs */ gpio_set_value(OSIRIS_GPIO_DVS, 1); osiris_dvs_tps_setdvs(false); cpufreq_unregister_notifier(&osiris_dvs_nb, CPUFREQ_TRANSITION_NOTIFIER); gpio_free(OSIRIS_GPIO_DVS); return 0; }
static int __devexit omap34_xx_bridge_remove(struct platform_device *pdev) { dev_t devno; bool ret; int status = 0; bhandle hdrv_obj = NULL; status = cfg_get_object((u32 *) &hdrv_obj, REG_DRV_OBJECT); if (DSP_FAILED(status)) goto func_cont; #ifdef CONFIG_BRIDGE_DVFS if (cpufreq_unregister_notifier(&iva_clk_notifier, CPUFREQ_TRANSITION_NOTIFIER)) pr_err("%s: clk_notifier_unregister failed for iva2_ck\n", __func__); #endif /* #ifdef CONFIG_BRIDGE_DVFS */ if (driver_context) { /* Put the DSP in reset state */ ret = dsp_deinit(driver_context); driver_context = 0; DBC_ASSERT(ret == true); } #ifdef CONFIG_BRIDGE_DVFS clk_put(clk_handle); clk_handle = NULL; #endif /* #ifdef CONFIG_BRIDGE_DVFS */ func_cont: mem_ext_phys_pool_release(); services_exit(); bridge_destroy_sysfs(); devno = MKDEV(driver_major, 0); cdev_del(&bridge_cdev); unregister_chrdev_region(devno, 1); if (bridge_class) { /* remove the device from sysfs */ device_destroy(bridge_class, MKDEV(driver_major, 0)); class_destroy(bridge_class); } return 0; }
/** * cpufreq_cooling_unregister - function to remove cpufreq cooling device. * @cdev: thermal cooling device pointer. * * This interface function unregisters the "thermal-cpufreq-%x" cooling device. */ void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev) { struct cpufreq_cooling_device *cpufreq_dev = cdev->devdata; mutex_lock(&cooling_cpufreq_lock); cpufreq_dev_count--; /* Unregister the notifier for the last cpufreq cooling device */ if (cpufreq_dev_count == 0) cpufreq_unregister_notifier(&thermal_cpufreq_notifier_block, CPUFREQ_POLICY_NOTIFIER); mutex_unlock(&cooling_cpufreq_lock); thermal_cooling_device_unregister(cpufreq_dev->cool_dev); release_idr(&cpufreq_idr, cpufreq_dev->id); kfree(cpufreq_dev); }
static int __devexit omap34_xx_bridge_remove(struct platform_device *pdev) { dev_t devno; int status = 0; struct drv_data *drv_datap = dev_get_drvdata(bridge); if (!drv_datap || !drv_datap->drv_object) { status = -ENODATA; pr_err("%s: Failed to retrieve the object handle\n", __func__); goto func_cont; } #ifdef CONFIG_TIDSPBRIDGE_DVFS if (cpufreq_unregister_notifier(&iva_clk_notifier, CPUFREQ_TRANSITION_NOTIFIER)) pr_err("%s: cpufreq_unregister_notifier failed for iva2_ck\n", __func__); #endif if (driver_context) { dsp_deinit(driver_context); driver_context = 0; } kfree(drv_datap); dev_set_drvdata(bridge, NULL); func_cont: mem_ext_phys_pool_release(); dsp_clk_exit(); devno = MKDEV(driver_major, 0); cdev_del(&bridge_cdev); unregister_chrdev_region(devno, 1); if (bridge_class) { device_destroy(bridge_class, MKDEV(driver_major, 0)); class_destroy(bridge_class); } return 0; }
static void disable_msm_thermal(void) { int cpu = 0; struct cpufreq_policy *cpu_policy = NULL; cpufreq_unregister_notifier(&msm_thermal_notifier_block, CPUFREQ_POLICY_NOTIFIER); cancel_delayed_work(&check_temp_work); mutex_lock(&policy_mutex); for_each_possible_cpu(cpu) { cpu_policy = per_cpu(policy, cpu); if (cpu_policy && cpu_policy->max < cpu_policy->cpuinfo.max_freq) update_cpu_max_freq(cpu, cpu_policy->cpuinfo.max_freq); } mutex_unlock(&policy_mutex); unregister_hotcpu_notifier(&msm_thermal_hotcpu_notify); }
/* sa1100_pcmcia_driver_shutdown() * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ * Invokes the low-level kernel service to free IRQs associated with this * socket controller and reset GPIO edge detection. */ static void __exit sa1100_pcmcia_driver_shutdown(void) { int i; del_timer_sync(&poll_timer); unregister_ss_entry(&sa1100_pcmcia_operations); #ifdef CONFIG_CPU_FREQ cpufreq_unregister_notifier(&sa1100_pcmcia_notifier_block); #endif for (i = 0; i < sa1100_pcmcia_socket_count; i++) { iounmap(sa1100_pcmcia_socket[i].virt_io); release_mem_region(_PCMCIA(i), PCMCIASp); } pcmcia_low_level->shutdown(); flush_scheduled_tasks(); }
void soc_pcmcia_remove_one(struct soc_pcmcia_socket *skt) { del_timer_sync(&skt->poll_timer); pcmcia_unregister_socket(&skt->socket); #ifdef CONFIG_CPU_FREQ if (skt->ops->frequency_change) cpufreq_unregister_notifier(&skt->cpufreq_nb, CPUFREQ_TRANSITION_NOTIFIER); #endif soc_pcmcia_hw_shutdown(skt); /* should not be required; violates some lowlevel drivers */ soc_common_pcmcia_config_skt(skt, &dead_socket); iounmap(skt->virt_io); skt->virt_io = NULL; release_resource(&skt->res_attr); release_resource(&skt->res_mem); release_resource(&skt->res_io); release_resource(&skt->res_skt); }
static inline void s3c2410wdt_cpufreq_deregister(void) { cpufreq_unregister_notifier(&s3c2410wdt_cpufreq_transition_nb, CPUFREQ_TRANSITION_NOTIFIER); }
static inline void s3c24xx_serial_cpufreq_deregister(struct s3c24xx_uart_port *port) { cpufreq_unregister_notifier(&port->freq_transition, CPUFREQ_TRANSITION_NOTIFIER); }