Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * cpuidle driver for haltpoll governor.
       4                 :            :  *
       5                 :            :  * Copyright 2019 Red Hat, Inc. and/or its affiliates.
       6                 :            :  *
       7                 :            :  * This work is licensed under the terms of the GNU GPL, version 2.  See
       8                 :            :  * the COPYING file in the top-level directory.
       9                 :            :  *
      10                 :            :  * Authors: Marcelo Tosatti <mtosatti@redhat.com>
      11                 :            :  */
      12                 :            : 
      13                 :            : #include <linux/init.h>
      14                 :            : #include <linux/cpu.h>
      15                 :            : #include <linux/cpuidle.h>
      16                 :            : #include <linux/module.h>
      17                 :            : #include <linux/sched/idle.h>
      18                 :            : #include <linux/kvm_para.h>
      19                 :            : #include <linux/cpuidle_haltpoll.h>
      20                 :            : 
      21                 :            : static struct cpuidle_device __percpu *haltpoll_cpuidle_devices;
      22                 :            : static enum cpuhp_state haltpoll_hp_state;
      23                 :            : 
      24                 :          0 : static int default_enter_idle(struct cpuidle_device *dev,
      25                 :            :                               struct cpuidle_driver *drv, int index)
      26                 :            : {
      27         [ #  # ]:          0 :         if (current_clr_polling_and_test()) {
      28                 :          0 :                 local_irq_enable();
      29                 :          0 :                 return index;
      30                 :            :         }
      31                 :          0 :         default_idle();
      32                 :          0 :         return index;
      33                 :            : }
      34                 :            : 
      35                 :            : static struct cpuidle_driver haltpoll_driver = {
      36                 :            :         .name = "haltpoll",
      37                 :            :         .governor = "haltpoll",
      38                 :            :         .states = {
      39                 :            :                 { /* entry 0 is for polling */ },
      40                 :            :                 {
      41                 :            :                         .enter                  = default_enter_idle,
      42                 :            :                         .exit_latency           = 1,
      43                 :            :                         .target_residency       = 1,
      44                 :            :                         .power_usage            = -1,
      45                 :            :                         .name                   = "haltpoll idle",
      46                 :            :                         .desc                   = "default architecture idle",
      47                 :            :                 },
      48                 :            :         },
      49                 :            :         .safe_state_index = 0,
      50                 :            :         .state_count = 2,
      51                 :            : };
      52                 :            : 
      53                 :          0 : static int haltpoll_cpu_online(unsigned int cpu)
      54                 :            : {
      55                 :          0 :         struct cpuidle_device *dev;
      56                 :            : 
      57                 :          0 :         dev = per_cpu_ptr(haltpoll_cpuidle_devices, cpu);
      58         [ #  # ]:          0 :         if (!dev->registered) {
      59                 :          0 :                 dev->cpu = cpu;
      60         [ #  # ]:          0 :                 if (cpuidle_register_device(dev)) {
      61                 :          0 :                         pr_notice("cpuidle_register_device %d failed!\n", cpu);
      62                 :          0 :                         return -EIO;
      63                 :            :                 }
      64                 :          0 :                 arch_haltpoll_enable(cpu);
      65                 :            :         }
      66                 :            : 
      67                 :            :         return 0;
      68                 :            : }
      69                 :            : 
      70                 :          0 : static int haltpoll_cpu_offline(unsigned int cpu)
      71                 :            : {
      72                 :          0 :         struct cpuidle_device *dev;
      73                 :            : 
      74                 :          0 :         dev = per_cpu_ptr(haltpoll_cpuidle_devices, cpu);
      75         [ #  # ]:          0 :         if (dev->registered) {
      76                 :          0 :                 arch_haltpoll_disable(cpu);
      77                 :          0 :                 cpuidle_unregister_device(dev);
      78                 :            :         }
      79                 :            : 
      80                 :          0 :         return 0;
      81                 :            : }
      82                 :            : 
      83                 :          0 : static void haltpoll_uninit(void)
      84                 :            : {
      85         [ #  # ]:          0 :         if (haltpoll_hp_state)
      86                 :          0 :                 cpuhp_remove_state(haltpoll_hp_state);
      87                 :          0 :         cpuidle_unregister_driver(&haltpoll_driver);
      88                 :            : 
      89                 :          0 :         free_percpu(haltpoll_cpuidle_devices);
      90                 :          0 :         haltpoll_cpuidle_devices = NULL;
      91                 :          0 : }
      92                 :            : 
      93                 :         13 : static int __init haltpoll_init(void)
      94                 :            : {
      95                 :         13 :         int ret;
      96                 :         13 :         struct cpuidle_driver *drv = &haltpoll_driver;
      97                 :            : 
      98                 :            :         /* Do not load haltpoll if idle= is passed */
      99         [ +  - ]:         13 :         if (boot_option_idle_override != IDLE_NO_OVERRIDE)
     100                 :            :                 return -ENODEV;
     101                 :            : 
     102                 :         13 :         cpuidle_poll_state_init(drv);
     103                 :            : 
     104   [ +  -  +  - ]:         26 :         if (!kvm_para_available() ||
     105                 :            :                 !kvm_para_has_hint(KVM_HINTS_REALTIME))
     106                 :         13 :                 return -ENODEV;
     107                 :            : 
     108                 :          0 :         ret = cpuidle_register_driver(drv);
     109         [ #  # ]:          0 :         if (ret < 0)
     110                 :            :                 return ret;
     111                 :            : 
     112                 :          0 :         haltpoll_cpuidle_devices = alloc_percpu(struct cpuidle_device);
     113         [ #  # ]:          0 :         if (haltpoll_cpuidle_devices == NULL) {
     114                 :          0 :                 cpuidle_unregister_driver(drv);
     115                 :          0 :                 return -ENOMEM;
     116                 :            :         }
     117                 :            : 
     118                 :          0 :         ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "cpuidle/haltpoll:online",
     119                 :            :                                 haltpoll_cpu_online, haltpoll_cpu_offline);
     120         [ #  # ]:          0 :         if (ret < 0) {
     121                 :          0 :                 haltpoll_uninit();
     122                 :            :         } else {
     123                 :          0 :                 haltpoll_hp_state = ret;
     124                 :          0 :                 ret = 0;
     125                 :            :         }
     126                 :            : 
     127                 :            :         return ret;
     128                 :            : }
     129                 :            : 
     130                 :          0 : static void __exit haltpoll_exit(void)
     131                 :            : {
     132                 :          0 :         haltpoll_uninit();
     133                 :          0 : }
     134                 :            : 
     135                 :            : module_init(haltpoll_init);
     136                 :            : module_exit(haltpoll_exit);
     137                 :            : MODULE_LICENSE("GPL");
     138                 :            : MODULE_AUTHOR("Marcelo Tosatti <mtosatti@redhat.com>");