static int __init exynos4_init_cpuidle(void) { int i, max_cpuidle_state, cpu_id; struct cpuidle_device *device; struct cpuidle_driver *drv = &exynos4_idle_driver; /* Setup cpuidle driver */ drv->state_count = (sizeof(exynos4_cpuidle_set) / sizeof(struct cpuidle_state)); max_cpuidle_state = drv->state_count; for (i = 0; i < max_cpuidle_state; i++) { memcpy(&drv->states[i], &exynos4_cpuidle_set[i], sizeof(struct cpuidle_state)); } cpuidle_register_driver(&exynos4_idle_driver); for_each_cpu(cpu_id, cpu_online_mask) { device = &per_cpu(exynos4_cpuidle_device, cpu_id); device->cpu = cpu_id; device->state_count = drv->state_count; if (cpuidle_register_device(device)) { printk(KERN_ERR "CPUidle register device failed\n,"); return -EIO; } }
/* Initialize CPU idle by registering the idle states */ static int s5p6442_init_cpuidle(void) { struct cpuidle_device *device; cpuidle_register_driver(&s5p6442_idle_driver); device = &per_cpu(s5p6442_cpuidle_device, smp_processor_id()); device->state_count = 1; /* Wait for interrupt state */ device->states[0].enter = s5p6442_enter_idle_normal; device->states[0].exit_latency = 1; /* uS */ device->states[0].target_residency = 10000; device->states[0].flags = CPUIDLE_FLAG_TIME_VALID; strcpy(device->states[0].name, "IDLE"); strcpy(device->states[0].desc, "ARM clock gating - WFI"); if (cpuidle_register_device(device)) { printk(KERN_ERR "s5p6442_init_cpuidle: Failed registering\n"); return -EIO; } spin_lock_init(&idle2_lock); return 0; }
/* Initialize CPU idle by registering the idle states */ static int xilinx_init_cpuidle(void) { unsigned int cpu; struct cpuidle_device *device; int ret; ret = cpuidle_register_driver(&xilinx_idle_driver); if (ret) { pr_err("Registering Xilinx CpuIdle Driver failed.\n"); return ret; } for_each_possible_cpu(cpu) { device = &per_cpu(xilinx_cpuidle_device, cpu); device->state_count = XILINX_MAX_STATES; device->cpu = cpu; ret = cpuidle_register_device(device); if (ret) { pr_err("xilinx_init_cpuidle: Failed registering\n"); return ret; } } pr_info("Xilinx CpuIdle Driver started\n"); return 0; }
static int __init rk30_cpuidle_init(void) { struct cpuidle_device *dev; unsigned int cpu; int ret; ret = cpuidle_register_driver(&rk30_cpuidle_driver); if (ret) { pr_err("failed to register cpuidle driver: %d\n", ret); return ret; } for_each_possible_cpu(cpu) { dev = &per_cpu(rk30_cpuidle_device, cpu); dev->cpu = cpu; dev->state_count = ARRAY_SIZE(rk30_cpuidle_states); memcpy(dev->states, rk30_cpuidle_states, sizeof(rk30_cpuidle_states)); dev->safe_state = &dev->states[0]; ret = cpuidle_register_device(dev); if (ret) { pr_err("failed to register cpuidle device for cpu %u: %d\n", cpu, ret); return ret; } } return 0; }
static int imx_cpuidle_register(struct imx_cpuidle_state *pstate) { struct cpuidle_device *device; struct cpuidle_state *state = pstate->state; int i; cpuidle_register_driver(&imx_cpuidle_driver); device = &per_cpu(imx_cpuidle_device, smp_processor_id()); device->state_count = pstate->state_number; for (i = 0; i < device->state_count; i++) { device->states[i].enter = state[i].enter; device->states[i].exit_latency = state[i].exit_latency; device->states[i].target_residency = state[i].target_residency; device->states[i].flags = state[i].flags; strcpy(device->states[i].name, state[i].name); strcpy(device->states[i].desc, state[i].desc); } if (cpuidle_register_device(device)) { printk(KERN_ERR "imx_cpuidle_register: Failed registering\n"); return -EIO; } return 0; }
static int __init tegra_cpuidle_init(void) { unsigned int cpu; int ret; ret = cpuidle_register_driver(&tegra_idle); if (ret) return ret; #ifdef CONFIG_PM_SLEEP tegra_lp2_min_residency = tegra_cpu_lp2_min_residency(); tegra_lp2_exit_latency = tegra_cpu_power_good_time(); tegra_lp2_power_off_time = tegra_cpu_power_off_time(); ret = tegra_cpudile_init_soc(); if (ret) return ret; #endif for_each_possible_cpu(cpu) { if (tegra_cpuidle_register_device(cpu)) pr_err("CPU%u: error initializing idle loop\n", cpu); } register_pm_notifier(&tegra_cpuidle_pm_notifier); return 0; }
static int __init pseries_processor_idle_init(void) { int retval; retval = pseries_idle_probe(); if (retval) return retval; pseries_cpuidle_driver_init(); retval = cpuidle_register_driver(&pseries_idle_driver); if (retval) { printk(KERN_DEBUG "Registration of pseries driver failed.\n"); return retval; } retval = pseries_idle_devices_init(); if (retval) { pseries_idle_devices_uninit(); cpuidle_unregister_driver(&pseries_idle_driver); return retval; } register_cpu_notifier(&setup_hotplug_notifier); printk(KERN_DEBUG "pseries_idle_driver registered\n"); return 0; }
void sh_mobile_setup_cpuidle(void) { struct cpuidle_device *dev = &cpuidle_dev; struct cpuidle_driver *drv = &cpuidle_driver; struct cpuidle_state *state; int i; for (i = 0; i < CPUIDLE_STATE_MAX; i++) { drv->states[i].name[0] = '\0'; drv->states[i].desc[0] = '\0'; } i = CPUIDLE_DRIVER_STATE_START; state = &drv->states[i++]; snprintf(state->name, CPUIDLE_NAME_LEN, "C1"); strncpy(state->desc, "SuperH Sleep Mode", CPUIDLE_DESC_LEN); state->exit_latency = 1; state->target_residency = 1 * 2; state->power_usage = 3; state->flags = 0; state->flags |= CPUIDLE_FLAG_TIME_VALID; state->enter = cpuidle_sleep_enter; drv->safe_state_index = i-1; if (sh_mobile_sleep_supported & SUSP_SH_SF) { state = &drv->states[i++]; snprintf(state->name, CPUIDLE_NAME_LEN, "C2"); strncpy(state->desc, "SuperH Sleep Mode [SF]", CPUIDLE_DESC_LEN); state->exit_latency = 100; state->target_residency = 1 * 2; state->power_usage = 1; state->flags = 0; state->flags |= CPUIDLE_FLAG_TIME_VALID; state->enter = cpuidle_sleep_enter; } if (sh_mobile_sleep_supported & SUSP_SH_STANDBY) { state = &drv->states[i++]; snprintf(state->name, CPUIDLE_NAME_LEN, "C3"); strncpy(state->desc, "SuperH Mobile Standby Mode [SF]", CPUIDLE_DESC_LEN); state->exit_latency = 2300; state->target_residency = 1 * 2; state->power_usage = 1; state->flags = 0; state->flags |= CPUIDLE_FLAG_TIME_VALID; state->enter = cpuidle_sleep_enter; } drv->state_count = i; dev->state_count = i; cpuidle_register_driver(&cpuidle_driver); cpuidle_register_device(dev); }
/* Initialize CPU idle by registering the idle states */ static int kirkwood_init_cpuidle(void) { struct cpuidle_device *device; cpuidle_register_driver(&kirkwood_idle_driver); device = &per_cpu(kirkwood_cpuidle_device, smp_processor_id()); device->state_count = KIRKWOOD_MAX_STATES; /* Wait for interrupt state */ device->states[0].enter = kirkwood_enter_idle; device->states[0].exit_latency = 1; device->states[0].target_residency = 10000; device->states[0].flags = CPUIDLE_FLAG_TIME_VALID; strcpy(device->states[0].name, "WFI"); strcpy(device->states[0].desc, "Wait for interrupt"); /* Wait for interrupt and DDR self refresh state */ device->states[1].enter = kirkwood_enter_idle; device->states[1].exit_latency = 10; device->states[1].target_residency = 10000; device->states[1].flags = CPUIDLE_FLAG_TIME_VALID; strcpy(device->states[1].name, "DDR SR"); strcpy(device->states[1].desc, "WFI and DDR Self Refresh"); if (cpuidle_register_device(device)) { printk(KERN_ERR "kirkwood_init_cpuidle: Failed registering\n"); return -EIO; } return 0; }
int __devinit msm_cpuidle_init(void) { unsigned int cpu = 0; int ret = 0; msm_cpuidle_set_states(); ret = cpuidle_register_driver(&msm_cpuidle_driver); if (ret) pr_err("%s: failed to register cpuidle driver: %d\n", __func__, ret); for_each_possible_cpu(cpu) { struct cpuidle_device *dev = &per_cpu(msm_cpuidle_devs, cpu); dev->cpu = cpu; msm_cpuidle_set_cpu_statedata(dev); ret = cpuidle_register_device(dev); if (ret) { pr_err("%s: failed to register cpuidle device for " "cpu %u: %d\n", __func__, cpu, ret); return ret; } } return 0; }
int __init tegra30_cpuidle_init(void) { int ret; unsigned int cpu; struct cpuidle_device *dev; struct cpuidle_driver *drv = &tegra_idle_driver; #ifdef CONFIG_PM_SLEEP tegra_tear_down_cpu = tegra30_tear_down_cpu; #endif ret = cpuidle_register_driver(&tegra_idle_driver); if (ret) { pr_err("CPUidle driver registration failed\n"); return ret; } for_each_possible_cpu(cpu) { dev = &per_cpu(tegra_idle_device, cpu); dev->cpu = cpu; dev->state_count = drv->state_count; ret = cpuidle_register_device(dev); if (ret) { pr_err("CPU%u: CPUidle device registration failed\n", cpu); return ret; } } return 0; }
/* * bl_idle_init * * Registers the bl specific cpuidle driver with the cpuidle * framework with the valid set of states. */ int __init bl_idle_init(void) { struct cpuidle_device *dev; int i, cpu_id; struct cpuidle_driver *drv = &bl_idle_driver; if (!of_find_compatible_node(NULL, NULL, "arm,generic")) { pr_info("%s: No compatible node found\n", __func__); return -ENODEV; } drv->state_count = (sizeof(bl_cpuidle_set) / sizeof(struct cpuidle_state)); for (i = 0; i < drv->state_count; i++) { memcpy(&drv->states[i], &bl_cpuidle_set[i], sizeof(struct cpuidle_state)); } cpuidle_register_driver(drv); for_each_cpu(cpu_id, cpu_online_mask) { pr_err("CPUidle for CPU%d registered\n", cpu_id); dev = &per_cpu(bl_idle_dev, cpu_id); dev->cpu = cpu_id; dev->state_count = drv->state_count; if (cpuidle_register_device(dev)) { printk(KERN_ERR "%s: Cpuidle register device failed\n", __func__); return -EIO; } }
static int __init acpi_processor_init(void) { int result = 0; if (acpi_disabled) return 0; memset(&errata, 0, sizeof(errata)); #ifdef CONFIG_SMP if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_MADT, 0, (struct acpi_table_header **)&madt))) madt = NULL; #endif #ifdef CONFIG_ACPI_PROCFS acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir); if (!acpi_processor_dir) return -ENOMEM; #endif /* * Check whether the system is DMI table. If yes, OSPM * should not use mwait for CPU-states. */ dmi_check_system(processor_idle_dmi_table); if (!cpuidle_register_driver(&acpi_idle_driver)) { printk(KERN_DEBUG "ACPI: %s registered with cpuidle\n", acpi_idle_driver.name); } else { printk(KERN_DEBUG "ACPI: acpi_idle yielding to %s", cpuidle_get_driver()->name); } result = acpi_bus_register_driver(&acpi_processor_driver); if (result < 0) goto out_cpuidle; acpi_processor_install_hotplug_notify(); acpi_thermal_cpufreq_init(); acpi_processor_ppc_init(); acpi_processor_throttling_init(); return 0; out_cpuidle: cpuidle_unregister_driver(&acpi_idle_driver); #ifdef CONFIG_ACPI_PROCFS remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir); #endif return result; }
int shmobile_cpuidle_init(void) { struct cpuidle_device *dev = &shmobile_cpuidle_dev; cpuidle_register_driver(cpuidle_drv); dev->state_count = cpuidle_drv->state_count; cpuidle_register_device(dev); return 0; }
/** * omap3_idle_init - Init routine for OMAP3 idle * * Registers the OMAP3 specific cpuidle driver with the cpuidle * framework with the valid set of states. */ int __init omap3_idle_init(void) { int i, count = 0; struct omap3_processor_cx *cx; struct cpuidle_state *state; struct cpuidle_device *dev; mpu_pd = pwrdm_lookup("mpu_pwrdm"); core_pd = pwrdm_lookup("core_pwrdm"); per_pd = pwrdm_lookup("per_pwrdm"); cam_pd = pwrdm_lookup("cam_pwrdm"); omap_init_power_states(); cpuidle_register_driver(&omap3_idle_driver); dev = &per_cpu(omap3_idle_dev, smp_processor_id()); for (i = OMAP3_STATE_C1; i < OMAP3_MAX_STATES; i++) { cx = &omap3_power_states[i]; state = &dev->states[count]; if (!cx->valid) continue; cpuidle_set_statedata(state, cx); state->exit_latency = cx->sleep_latency + cx->wakeup_latency; state->target_residency = cx->threshold; state->flags = cx->flags; state->enter = (state->flags & CPUIDLE_FLAG_CHECK_BM) ? omap3_enter_idle_bm : omap3_enter_idle; if (cx->type == OMAP3_STATE_C1) dev->safe_state = state; sprintf(state->name, "C%d", count+1); strncpy(state->desc, cx->desc, CPUIDLE_DESC_LEN); count++; } if (!count) return -EINVAL; dev->state_count = count; if (enable_off_mode) omap3_cpuidle_update_states(PWRDM_POWER_OFF, PWRDM_POWER_OFF); else omap3_cpuidle_update_states(PWRDM_POWER_RET, PWRDM_POWER_RET); if (cpuidle_register_device(dev)) { printk(KERN_ERR "%s: CPUidle register device failed\n", __func__); return -EIO; } return 0; }
static __init int omap3_idle_init(void) { int i, count = 0; struct omap3_processor_cx *cx; struct cpuidle_state *state; struct cpuidle_device *dev; printk(KERN_INFO "OMAP CPU idle driver initializing.\n"); cpuidle_register_driver(&omap3_idle_driver); dev = &per_cpu(omap3_idle_dev, smp_processor_id()); for (i = 0; i < OMAP3_MAX_STATES; i++) { cx = &omap3_power_states[i]; state = &dev->states[count]; if (!cx->valid) continue; cpuidle_set_statedata(state, cx); state->exit_latency = cx->sleep_latency + cx->wakeup_latency; state->target_residency = cx->threshold; state->flags = cx->flags; state->enter = (state->flags & CPUIDLE_FLAG_CHECK_BM) ? omap3_enter_idle_bm : omap3_enter_idle; if (cx->type == OMAP3_STATE_C3) dev->safe_state = state; snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", count+1); count++; BUG_ON(count == CPUIDLE_STATE_MAX); /* harsh... oh well */ } if (!count) return -EINVAL; /* No valid states configured. */ dev->state_count = count; if (cpuidle_register_device(dev)) { printk(KERN_ERR "%s: CPUidle register device failed\n", __FUNCTION__); return -EIO; } create_pmproc_entry(); /* Initialize UART inactivity time */ uart_inactivity_timeout = msecs_to_jiffies(UART_TIME_OUT); uart_last_awake = jiffies; return 0; }
static int kirkwood_init_cpuidle(void) { struct cpuidle_device *device; device = &per_cpu(kirkwood_cpuidle_device, smp_processor_id()); device->state_count = KIRKWOOD_MAX_STATES; cpuidle_register_driver(&kirkwood_idle_driver); if (cpuidle_register_device(device)) { printk(KERN_ERR "kirkwood_init_cpuidle: Failed registering\n"); return -EIO; } return 0; }
/** * omap4_idle_init - Init routine for OMAP4 idle * * Registers the OMAP4 specific cpuidle driver with the cpuidle * framework with the valid set of states. */ int __init omap4_idle_init(void) { int cpu_id, i, count = 0; struct omap4_processor_cx *cx; struct cpuidle_state *state; struct cpuidle_device *dev; mpu_pd = pwrdm_lookup("mpu_pwrdm"); cpu1_pd = pwrdm_lookup("cpu1_pwrdm"); core_pd = pwrdm_lookup("core_pwrdm"); omap_init_power_states(); cpuidle_register_driver(&omap4_idle_driver); for_each_cpu(cpu_id, cpu_online_mask) { pr_err("CPUidle for CPU%d registered\n", cpu_id); dev = &per_cpu(omap4_idle_dev, cpu_id); dev->cpu = cpu_id; count = 0; for (i = OMAP4_STATE_C1; i < OMAP4_MAX_STATES; i++) { cx = &omap4_power_states[i]; state = &dev->states[count]; if (!cx->valid) continue; cpuidle_set_statedata(state, cx); state->exit_latency = cx->sleep_latency + cx->wakeup_latency; state->target_residency = cx->threshold; state->flags = cx->flags; if (cx->type == OMAP4_STATE_C1) dev->safe_state = state; state->enter = (state->flags & CPUIDLE_FLAG_CHECK_BM) ? omap4_enter_idle_bm : omap4_enter_idle; sprintf(state->name, "C%d", count+1); strncpy(state->desc, cx->desc, CPUIDLE_DESC_LEN); count++; } if (!count) return -EINVAL; dev->state_count = count; if (cpuidle_register_device(dev)) { printk(KERN_ERR "%s: CPUidle register device failed\n", __func__); return -EIO; } }
static int __init acpi_processor_init(void) { int result = 0; memset(&errata, 0, sizeof(errata)); #ifdef CONFIG_SMP if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_MADT, 0, (struct acpi_table_header **)&madt))) madt = NULL; #endif acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir); if (!acpi_processor_dir) return -ENOMEM; acpi_processor_dir->owner = THIS_MODULE; /* * Check whether the system is DMI table. If yes, OSPM * should not use mwait for CPU-states. */ dmi_check_system(processor_idle_dmi_table); result = cpuidle_register_driver(&acpi_idle_driver); if (result < 0) goto out_proc; result = acpi_bus_register_driver(&acpi_processor_driver); if (result < 0) goto out_cpuidle; acpi_processor_install_hotplug_notify(); acpi_thermal_cpufreq_init(); acpi_processor_ppc_init(); acpi_processor_throttling_init(); return 0; out_cpuidle: cpuidle_unregister_driver(&acpi_idle_driver); out_proc: remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir); return result; }
int omap3_idle_init(void) { int i, count = 0; struct omap3_processor_cx *cx; struct cpuidle_state *state; struct cpuidle_device *dev; omap_init_power_states(); cpuidle_register_driver(&omap3_idle_driver); dev = &per_cpu(omap3_idle_dev, smp_processor_id()); for (i = 0; i < OMAP3_MAX_STATES; i++) { cx = &omap3_power_states[i]; state = &dev->states[count]; if (!cx->valid) continue; cpuidle_set_statedata(state, cx); state->exit_latency = cx->sleep_latency + cx->wakeup_latency; state->target_residency = cx->threshold; state->flags = cx->flags; state->enter = (state->flags & CPUIDLE_FLAG_CHECK_BM) ? omap3_enter_idle_bm : omap3_enter_idle; if (cx->type == OMAP3_STATE_C2) dev->safe_state = state; sprintf(state->name, "C%d", count+1); count++; } if (!count) return -EINVAL; dev->state_count = count; if (cpuidle_register_device(dev)) { printk(KERN_ERR "%s: CPUidle register device failed\n", __FUNCTION__); return -EIO; } #ifdef CONFIG_PROC_FS create_pmproc_entry(); #endif /* #ifdef CONFIG_PROC_FS */ /* Initialize UART inactivity time */ awake_time_end = jiffies + msecs_to_jiffies(UART_TIME_OUT); return 0; }
static int __init s3c64xx_init_cpuidle(void) { int ret; memcpy(s3c64xx_cpuidle_driver.states, s3c64xx_cpuidle_set, sizeof(s3c64xx_cpuidle_set)); cpuidle_register_driver(&s3c64xx_cpuidle_driver); ret = cpuidle_register_device(&s3c64xx_cpuidle_device); if (ret) { pr_err("Failed to register cpuidle device: %d\n", ret); return ret; } return 0; }
static int __init acpi_processor_init(void) { int result = 0; if (acpi_disabled) return 0; memset(&errata, 0, sizeof(errata)); #ifdef CONFIG_SMP if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_MADT, 0, (struct acpi_table_header **)&madt))) madt = NULL; #endif #ifdef CONFIG_ACPI_PROCFS acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir); if (!acpi_processor_dir) return -ENOMEM; #endif result = cpuidle_register_driver(&acpi_idle_driver); if (result < 0) goto out_proc; result = acpi_bus_register_driver(&acpi_processor_driver); if (result < 0) goto out_cpuidle; acpi_processor_install_hotplug_notify(); acpi_thermal_cpufreq_init(); acpi_processor_ppc_init(); acpi_processor_throttling_init(); return 0; out_cpuidle: cpuidle_unregister_driver(&acpi_idle_driver); out_proc: #ifdef CONFIG_ACPI_PROCFS remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir); #endif return result; }
void sh_mobile_setup_cpuidle(void) { struct cpuidle_device *dev = &cpuidle_dev; struct cpuidle_state *state; int i; cpuidle_register_driver(&cpuidle_driver); for (i = 0; i < CPUIDLE_STATE_MAX; i++) { dev->states[i].name[0] = '\0'; dev->states[i].desc[0] = '\0'; } i = CPUIDLE_DRIVER_STATE_START; state = &dev->states[i++]; <<<<<<< HEAD
/* Initialize CPU idle by registering the idle states */ static int kw_cpuidle_probe(struct platform_device *pdev) { struct cpuidle_device *device; cpuidle_register_driver(&kirkwood_idle_driver); device = &per_cpu(kirkwood_cpuidle_device, smp_processor_id()); device->state_count = KIRKWOOD_MAX_STATES; /* Wait for interrupt state */ device->states[0].enter = kirkwood_enter_idle; device->states[0].exit_latency = 1; device->states[0].target_residency = 100; device->states[0].flags = CPUIDLE_FLAG_TIME_VALID; strcpy(device->states[0].name, "WFI"); strcpy(device->states[0].desc, "Wait for interrupt"); /* CPU Deep Idle state */ device->states[1].enter = kirkwood_enter_idle; device->states[1].exit_latency = 10; device->states[1].target_residency = 5000; device->states[1].flags = CPUIDLE_FLAG_TIME_VALID; strcpy(device->states[1].name, "DEEP IDLE"); strcpy(device->states[1].desc, "CPU Deep Idle"); #if 0 if (cpuidle_register_device(device)) { printk(KERN_ERR "kirkwood_init_cpuidle: Failed registering\n"); return -EIO; } #endif kirkwood_cpu_idle_device = device; #ifdef CONFIG_MV_PMU_PROC /* Create proc entry. */ cpu_idle_proc = create_proc_entry("cpu_idle", 0666, mv_pm_proc_entry); cpu_idle_proc->read_proc = mv_cpu_idle_read; cpu_idle_proc->write_proc = mv_cpu_idle_write; cpu_idle_proc->nlink = 1; #endif /* CONFIG_MV_PMU_PROC */ return 0; }
static int shmobile_cpuidle_init(void) { struct cpuidle_device *dev = &shmobile_cpuidle_dev; struct cpuidle_driver *drv = &shmobile_cpuidle_driver; int i; for (i = 0; i < CPUIDLE_STATE_MAX; i++) drv->states[i].enter = shmobile_cpuidle_enter; if (shmobile_cpuidle_setup) shmobile_cpuidle_setup(drv); cpuidle_register_driver(drv); dev->state_count = drv->state_count; cpuidle_register_device(dev); return 0; }
static int __init sunxi_init_cpuidle(void) { int cpu; struct cpuidle_device *device; sun8i_cpuidle_state_init(); sunxi_idle_driver.safe_state_index = 0; cpuidle_register_driver(&sunxi_idle_driver); for_each_possible_cpu(cpu) { device = &per_cpu(sunxi_cpuidle_device, cpu); device->cpu = cpu; if (cpuidle_register_device(device)) { printk(KERN_ERR "CPUidle register device failed\n,"); return -EIO; } } return 0; }
static int __init wmt_cpuidle_driver_init(void) { struct cpuidle_device *device = NULL; if (wmt_cpuidle_check_env()) { printk(KERN_WARNING "wmt_cpuidle check env failed!\n"); return -EINVAL; } cpuidle_register_driver(&wmt_cpuidle_driver); device = &per_cpu(wmt_cpuidle_device, smp_processor_id()); device->state_count = WMT_CPU_IDLE_MAX_STATES; /* Wait for interrupt state */ device->states[0].enter = wmt_enter_idle; device->states[0].exit_latency = 1; device->states[0].target_residency = 10000; device->states[0].flags = CPUIDLE_FLAG_TIME_VALID; strcpy(device->states[0].name, "WFI"); strcpy(device->states[0].desc, "Wait for interrupt"); /* Wait for interrupt and DDR self refresh state */ device->states[1].enter = wmt_enter_idle; device->states[1].exit_latency = 10; device->states[1].target_residency = 10000; device->states[1].flags = CPUIDLE_FLAG_TIME_VALID; strcpy(device->states[1].name, "ZAC_OFF"); strcpy(device->states[1].desc, "WFI and disable ZAC clock"); if (cpuidle_register_device(device)) { printk(KERN_ERR "wmt_cpuidle_driver_init: Failed registering\n"); return -EIO; } printk(KERN_INFO "WMT cpuidle driver register\n"); return 0; }
/** * cpuidle_init - Init routine for v9r1 idle * * Registers the v9r1 specific cpuidle driver to the cpuidle * framework with the valid set of states. */ int __init cpuidle_init(void) { struct cpuidle_device *dev; int i, max_cpuidle_state, cpu_id; cpuidle_register_driver(&idle_driver); wdt_base = ioremap(REG_BASE_WD0, REG_WD0_IOSIZE); gp_cpuidle_state = (unsigned int *)MEM_AXI_CPU_IDLE_ADDR; *gp_cpuidle_state = (CPU_IDLE_C4 << CPUIDLE_STATE_START_BIT) | (CPU_IDLE_STAT_VALID << CPUIDLE_STATE_MAGIC_START_BIT);/*init*/ for_each_cpu(cpu_id, cpu_online_mask) { dev = &per_cpu(idle_dev, cpu_id); dev->cpu = cpu_id; printk(KERN_ERR "cpu=%d\n", dev->cpu); if (cpu_id == 0) dev->state_count = ARRAY_SIZE(cpuidle_set); else dev->state_count = 1; /* Support IDLE only */ max_cpuidle_state = dev->state_count; for (i = 0; i < max_cpuidle_state; i++) { memcpy(&dev->states[i], &cpuidle_set[i], sizeof(struct cpuidle_state)); } dev->safe_state = &dev->states[0]; if (cpuidle_register_device(dev)) { cpuidle_unregister_driver(&idle_driver); printk(KERN_ERR "CPUidle register device failed\n,"); return -EIO; } }
/** * cpuidle_register: registers the driver and the cpu devices with the * coupled_cpus passed as parameter. This function is used for all common * initialization pattern there are in the arch specific drivers. The * devices is globally defined in this file. * * @drv : a valid pointer to a struct cpuidle_driver * @coupled_cpus: a cpumask for the coupled states * * Returns 0 on success, < 0 otherwise */ int cpuidle_register(struct cpuidle_driver *drv, const struct cpumask *const coupled_cpus) { int ret, cpu; struct cpuidle_device *device; ret = cpuidle_register_driver(drv); if (ret) { pr_err("failed to register cpuidle driver\n"); return ret; } for_each_possible_cpu(cpu) { device = &per_cpu(cpuidle_dev, cpu); device->cpu = cpu; #ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED /* * On multiplatform for ARM, the coupled idle states could * enabled in the kernel even if the cpuidle driver does not * use it. Note, coupled_cpus is a struct copy. */ if (coupled_cpus) device->coupled_cpus = *coupled_cpus; #endif ret = cpuidle_register_device(device); if (!ret) continue; pr_err("Failed to register cpuidle device for cpu%d\n", cpu); cpuidle_unregister(drv); break; } return ret; }
static int __init acpi_processor_init(void) { int result = 0; if (acpi_disabled) return 0; memset(&errata, 0, sizeof(errata)); if (!cpuidle_register_driver(&acpi_idle_driver)) { printk(KERN_DEBUG "ACPI: %s registered with cpuidle\n", acpi_idle_driver.name); } else { printk(KERN_DEBUG "ACPI: acpi_idle yielding to %s\n", cpuidle_get_driver()->name); } result = acpi_bus_register_driver(&acpi_processor_driver); if (result < 0) goto out_cpuidle; acpi_processor_install_hotplug_notify(); acpi_thermal_cpufreq_init(); acpi_processor_ppc_init(); acpi_processor_throttling_init(); return 0; out_cpuidle: cpuidle_unregister_driver(&acpi_idle_driver); return result; }