arch/s390/kernel/idle.c

   1 /*
   2  * Idle functions for s390.
   3  *
   4  * Copyright IBM Corp. 2014
   5  *
   6  * Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>
   7  */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/kernel_stat.h>
  11 #include <linux/kprobes.h>
  12 #include <linux/notifier.h>
  13 #include <linux/init.h>
  14 #include <linux/cpu.h>
  15 #include <asm/cputime.h>
  16 #include <asm/nmi.h>
  17 #include <asm/smp.h>
  18 #include "entry.h"
  19
  20 static DEFINE_PER_CPU(struct s390_idle_data, s390_idle);
  21
  22 void enabled_wait(void)
  23 {
  24         struct s390_idle_data *idle = this_cpu_ptr(&s390_idle);
  25         unsigned long long idle_time;
  26         unsigned long psw_mask;
  27
  28         trace_hardirqs_on();
  29
  30         /* Wait for external, I/O or machine check interrupt. */
  31         psw_mask = PSW_KERNEL_BITS | PSW_MASK_WAIT | PSW_MASK_DAT |
  32                 PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK;
  33         clear_cpu_flag(CIF_NOHZ_DELAY);
  34
  35         /* Call the assembler magic in entry.S */
  36         psw_idle(idle, psw_mask);
  37
  38         trace_hardirqs_off();
  39
  40         /* Account time spent with enabled wait psw loaded as idle time. */
  41         write_seqcount_begin(&idle->seqcount);
  42         idle_time = idle->clock_idle_exit - idle->clock_idle_enter;
  43         idle->clock_idle_enter = idle->clock_idle_exit = 0ULL;
  44         idle->idle_time += idle_time;
  45         idle->idle_count++;
  46         account_idle_time(idle_time);
  47         write_seqcount_end(&idle->seqcount);
  48 }
  49 NOKPROBE_SYMBOL(enabled_wait);
  50
  51 static ssize_t show_idle_count(struct device *dev,
  52                                 struct device_attribute *attr, char *buf)
  53 {
  54         struct s390_idle_data *idle = &per_cpu(s390_idle, dev->id);
  55         unsigned long long idle_count;
  56         unsigned int seq;
  57
  58         do {
  59                 seq = read_seqcount_begin(&idle->seqcount);
  60                 idle_count = ACCESS_ONCE(idle->idle_count);
  61                 if (ACCESS_ONCE(idle->clock_idle_enter))
  62                         idle_count++;
  63         } while (read_seqcount_retry(&idle->seqcount, seq));
  64         return sprintf(buf, "%llu\n", idle_count);
  65 }
  66 DEVICE_ATTR(idle_count, 0444, show_idle_count, NULL);
  67
  68 static ssize_t show_idle_time(struct device *dev,
  69                                 struct device_attribute *attr, char *buf)
  70 {
  71         struct s390_idle_data *idle = &per_cpu(s390_idle, dev->id);
  72         unsigned long long now, idle_time, idle_enter, idle_exit;
  73         unsigned int seq;
  74
  75         do {
  76                 now = get_tod_clock();
  77                 seq = read_seqcount_begin(&idle->seqcount);
  78                 idle_time = ACCESS_ONCE(idle->idle_time);
  79                 idle_enter = ACCESS_ONCE(idle->clock_idle_enter);
  80                 idle_exit = ACCESS_ONCE(idle->clock_idle_exit);
  81         } while (read_seqcount_retry(&idle->seqcount, seq));
  82         idle_time += idle_enter ? ((idle_exit ? : now) - idle_enter) : 0;
  83         return sprintf(buf, "%llu\n", idle_time >> 12);
  84 }
  85 DEVICE_ATTR(idle_time_us, 0444, show_idle_time, NULL);
  86
  87 cputime64_t arch_cpu_idle_time(int cpu)
  88 {
  89         struct s390_idle_data *idle = &per_cpu(s390_idle, cpu);
  90         unsigned long long now, idle_enter, idle_exit;
  91         unsigned int seq;
  92
  93         do {
  94                 now = get_tod_clock();
  95                 seq = read_seqcount_begin(&idle->seqcount);
  96                 idle_enter = ACCESS_ONCE(idle->clock_idle_enter);
  97                 idle_exit = ACCESS_ONCE(idle->clock_idle_exit);
  98         } while (read_seqcount_retry(&idle->seqcount, seq));
  99         return idle_enter ? ((idle_exit ?: now) - idle_enter) : 0;
 100 }
 101
 102 void arch_cpu_idle_enter(void)
 103 {
 104         local_mcck_disable();
 105 }
 106
 107 void arch_cpu_idle(void)
 108 {
 109         if (!test_cpu_flag(CIF_MCCK_PENDING))
 110                 /* Halt the cpu and keep track of cpu time accounting. */
 111                 enabled_wait();
 112         local_irq_enable();
 113 }
 114
 115 void arch_cpu_idle_exit(void)
 116 {
 117         local_mcck_enable();
 118         if (test_cpu_flag(CIF_MCCK_PENDING))
 119                 s390_handle_mcck();
 120 }
 121
 122 void arch_cpu_idle_dead(void)
 123 {
 124         cpu_die();
 125 }