static struct cpuidle_driver at91_idle_driver = {
        .name                   = "at91_idle",
        .owner                  = THIS_MODULE,
-       .en_core_tk_irqen       = 1,
        .states[0]              = ARM_CPUIDLE_WFI_STATE,
        .states[1]              = {
                .enter                  = at91_enter_idle,
 
 static struct cpuidle_driver davinci_idle_driver = {
        .name                   = "cpuidle-davinci",
        .owner                  = THIS_MODULE,
-       .en_core_tk_irqen       = 1,
        .states[0]              = ARM_CPUIDLE_WFI_STATE,
        .states[1]              = {
                .enter                  = davinci_enter_idle,
 
 static struct cpuidle_driver exynos4_idle_driver = {
        .name                   = "exynos4_idle",
        .owner                  = THIS_MODULE,
-       .en_core_tk_irqen       = 1,
 };
 
 /* Ext-GIC nIRQ/nFIQ is the only wakeup source in AFTR */
 
 static struct cpuidle_driver imx6q_cpuidle_driver = {
        .name = "imx6q_cpuidle",
        .owner = THIS_MODULE,
-       .en_core_tk_irqen = 1,
        .states = {
                /* WFI */
                ARM_CPUIDLE_WFI_STATE,
 
 static struct cpuidle_driver imx5_cpuidle_driver = {
        .name                   = "imx5_cpuidle",
        .owner                  = THIS_MODULE,
-       .en_core_tk_irqen       = 1,
        .states[0]      = {
                .enter                  = imx5_cpuidle_enter,
                .exit_latency           = 2,
 
 static struct cpuidle_driver omap3_idle_driver = {
        .name             = "omap3_idle",
        .owner            = THIS_MODULE,
-       .en_core_tk_irqen = 1,
        .states = {
                {
                        .enter            = omap3_enter_idle_bm,
 
 static struct cpuidle_driver omap4_idle_driver = {
        .name                           = "omap4_idle",
        .owner                          = THIS_MODULE,
-       .en_core_tk_irqen               = 1,
        .states = {
                {
                        /* C1 - CPU0 ON + CPU1 ON + MPU ON */
 
 static struct cpuidle_driver s3c64xx_cpuidle_driver = {
        .name   = "s3c64xx_cpuidle",
        .owner  = THIS_MODULE,
-       .en_core_tk_irqen = 1,
        .states = {
                {
                        .enter            = s3c64xx_enter_idle,
 
 static struct cpuidle_driver shmobile_cpuidle_default_driver = {
        .name                   = "shmobile_cpuidle",
        .owner                  = THIS_MODULE,
-       .en_core_tk_irqen       = 1,
        .states[0]              = ARM_CPUIDLE_WFI_STATE,
        .safe_state_index       = 0, /* C1 */
        .state_count            = 1,
 
 static struct cpuidle_driver sh7372_cpuidle_driver = {
        .name                   = "sh7372_cpuidle",
        .owner                  = THIS_MODULE,
-       .en_core_tk_irqen       = 1,
        .state_count            = 5,
        .safe_state_index       = 0, /* C1 */
        .states[0] = ARM_CPUIDLE_WFI_STATE,
 
 static struct cpuidle_driver tegra_idle_driver = {
        .name = "tegra_idle",
        .owner = THIS_MODULE,
-       .en_core_tk_irqen = 1,
        .state_count = 1,
        .states = {
                [0] = ARM_CPUIDLE_WFI_STATE_PWR(600),
 
 static struct cpuidle_driver tegra_idle_driver = {
        .name = "tegra_idle",
        .owner = THIS_MODULE,
-       .en_core_tk_irqen = 1,
        .states = {
                ARM_CPUIDLE_WFI_STATE_PWR(600),
 #ifdef CONFIG_PM_SLEEP
 
 static struct cpuidle_driver tegra_idle_driver = {
        .name = "tegra_idle",
        .owner = THIS_MODULE,
-       .en_core_tk_irqen = 1,
 #ifdef CONFIG_PM_SLEEP
        .state_count = 2,
 #else
 
 static struct cpuidle_driver ux500_idle_driver = {
        .name = "ux500_idle",
        .owner = THIS_MODULE,
-       .en_core_tk_irqen = 1,
        .states = {
                ARM_CPUIDLE_WFI_STATE,
                {
 
 struct cpuidle_driver pseries_idle_driver = {
        .name             = "pseries_idle",
        .owner            = THIS_MODULE,
-       .en_core_tk_irqen = 1,
 };
 
 #define MAX_IDLE_STATE_COUNT   2
 
 static struct cpuidle_driver cpuidle_driver = {
        .name   = "sh_idle",
        .owner  = THIS_MODULE,
-       .en_core_tk_irqen = 1,
        .states = {
                {
                        .exit_latency = 1,
 
 static struct cpuidle_driver apm_idle_driver = {
        .name = "apm_idle",
        .owner = THIS_MODULE,
-       .en_core_tk_irqen = 1,
        .states = {
                { /* entry 0 is for polling */ },
                { /* entry 1 is for APM idle */
 
 struct cpuidle_driver acpi_idle_driver = {
        .name =         "acpi_idle",
        .owner =        THIS_MODULE,
-       .en_core_tk_irqen = 1,
 };
 
 /**
 
 
 static struct cpuidle_driver calxeda_idle_driver = {
        .name = "calxeda_idle",
-       .en_core_tk_irqen = 1,
        .states = {
                ARM_CPUIDLE_WFI_STATE,
                {
 
 static struct cpuidle_driver kirkwood_idle_driver = {
        .name                   = "kirkwood_idle",
        .owner                  = THIS_MODULE,
-       .en_core_tk_irqen       = 1,
        .states[0]              = ARM_CPUIDLE_WFI_STATE,
        .states[1]              = {
                .enter                  = kirkwood_enter_idle,
 
 
 static int __cpuidle_register_device(struct cpuidle_device *dev);
 
-static inline int cpuidle_enter(struct cpuidle_device *dev,
-                               struct cpuidle_driver *drv, int index)
-{
-       struct cpuidle_state *target_state = &drv->states[index];
-       return target_state->enter(dev, drv, index);
-}
-
-static inline int cpuidle_enter_tk(struct cpuidle_device *dev,
-                              struct cpuidle_driver *drv, int index)
-{
-       return cpuidle_wrap_enter(dev, drv, index, cpuidle_enter);
-}
-
-typedef int (*cpuidle_enter_t)(struct cpuidle_device *dev,
-                              struct cpuidle_driver *drv, int index);
-
-static cpuidle_enter_t cpuidle_enter_ops;
-
 /**
  * cpuidle_play_dead - cpu off-lining
  *
  * @next_state: index into drv->states of the state to enter
  */
 int cpuidle_enter_state(struct cpuidle_device *dev, struct cpuidle_driver *drv,
-               int next_state)
+                       int index)
 {
        int entered_state;
 
-       entered_state = cpuidle_enter_ops(dev, drv, next_state);
+       struct cpuidle_state *target_state = &drv->states[index];
+       ktime_t time_start, time_end;
+       s64 diff;
+
+       time_start = ktime_get();
+
+       entered_state = target_state->enter(dev, drv, index);
+
+       time_end = ktime_get();
+
+       local_irq_enable();
+
+       diff = ktime_to_us(ktime_sub(time_end, time_start));
+       if (diff > INT_MAX)
+               diff = INT_MAX;
+
+       dev->last_residency = (int) diff;
 
        if (entered_state >= 0) {
                /* Update cpuidle counters */
        mutex_unlock(&cpuidle_lock);
 }
 
-/**
- * cpuidle_wrap_enter - performs timekeeping and irqen around enter function
- * @dev: pointer to a valid cpuidle_device object
- * @drv: pointer to a valid cpuidle_driver object
- * @index: index of the target cpuidle state.
- */
-int cpuidle_wrap_enter(struct cpuidle_device *dev,
-                               struct cpuidle_driver *drv, int index,
-                               int (*enter)(struct cpuidle_device *dev,
-                                       struct cpuidle_driver *drv, int index))
-{
-       ktime_t time_start, time_end;
-       s64 diff;
-
-       time_start = ktime_get();
-
-       index = enter(dev, drv, index);
-
-       time_end = ktime_get();
-
-       local_irq_enable();
-
-       diff = ktime_to_us(ktime_sub(time_end, time_start));
-       if (diff > INT_MAX)
-               diff = INT_MAX;
-
-       dev->last_residency = (int) diff;
-
-       return index;
-}
-
 #ifdef CONFIG_ARCH_HAS_CPU_RELAX
 static int poll_idle(struct cpuidle_device *dev,
                struct cpuidle_driver *drv, int index)
                        return ret;
        }
 
-       cpuidle_enter_ops = drv->en_core_tk_irqen ?
-               cpuidle_enter_tk : cpuidle_enter;
-
        poll_idle_init(drv);
 
        ret = cpuidle_add_device_sysfs(dev);
 
 static struct cpuidle_driver intel_idle_driver = {
        .name = "intel_idle",
        .owner = THIS_MODULE,
-       .en_core_tk_irqen = 1,
 };
 /* intel_idle.max_cstate=0 disables driver */
 static int max_cstate = CPUIDLE_STATE_MAX - 1;
 
        struct module           *owner;
        int                     refcnt;
 
-       /* set to 1 to use the core cpuidle time keeping (for all states). */
-       unsigned int            en_core_tk_irqen:1;
         /* used by the cpuidle framework to setup the broadcast timer */
        unsigned int            bctimer:1;
        /* states array must be ordered in decreasing power consumption */
 extern void cpuidle_resume(void);
 extern int cpuidle_enable_device(struct cpuidle_device *dev);
 extern void cpuidle_disable_device(struct cpuidle_device *dev);
-extern int cpuidle_wrap_enter(struct cpuidle_device *dev,
-                               struct cpuidle_driver *drv, int index,
-                               int (*enter)(struct cpuidle_device *dev,
-                                       struct cpuidle_driver *drv, int index));
 extern int cpuidle_play_dead(void);
 
 extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev);
 static inline int cpuidle_enable_device(struct cpuidle_device *dev)
 {return -ENODEV; }
 static inline void cpuidle_disable_device(struct cpuidle_device *dev) { }
-static inline int cpuidle_wrap_enter(struct cpuidle_device *dev,
-                               struct cpuidle_driver *drv, int index,
-                               int (*enter)(struct cpuidle_device *dev,
-                                       struct cpuidle_driver *drv, int index))
-{ return -ENODEV; }
 static inline int cpuidle_play_dead(void) {return -ENODEV; }
 #endif