1// SPDX-License-Identifier: GPL-2.0
 2/*
 3 *    Precise Delay Loops for S390
 4 *
 5 *    Copyright IBM Corp. 1999, 2008
 6 *    Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>,
 
 7 */
 8
 9#include <linux/processor.h>
10#include <linux/delay.h>
 
 
 
 
 
 
11#include <asm/div64.h>
12#include <asm/timex.h>
13
14void __delay(unsigned long loops)
15{
16	/*
17	 * Loop 'loops' times. Callers must not assume a specific
18	 * amount of time passes before this function returns.
19	 */
 
 
 
20	asm volatile("0: brct %0,0b" : : "d" ((loops/2) + 1));
21}
22EXPORT_SYMBOL(__delay);
23
24static void delay_loop(unsigned long delta)
25{
26	unsigned long end;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
27
28	end = get_tod_clock_monotonic() + delta;
29	while (!tod_after(get_tod_clock_monotonic(), end))
30		cpu_relax();
 
 
 
 
 
 
 
 
 
 
 
 
31}
32
33void __udelay(unsigned long usecs)
 
 
 
34{
35	delay_loop(usecs << 12);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
36}
37EXPORT_SYMBOL(__udelay);
38
39void __ndelay(unsigned long nsecs)
 
 
 
 
40{
 
 
 
 
 
 
 
 
 
 
 
41	nsecs <<= 9;
42	do_div(nsecs, 125);
43	delay_loop(nsecs);
 
 
 
 
44}
45EXPORT_SYMBOL(__ndelay);

 
  1/*
  2 *    Precise Delay Loops for S390
  3 *
  4 *    Copyright IBM Corp. 1999, 2008
  5 *    Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>,
  6 *		 Heiko Carstens <heiko.carstens@de.ibm.com>,
  7 */
  8
  9#include <linux/sched.h>
 10#include <linux/delay.h>
 11#include <linux/timex.h>
 12#include <linux/module.h>
 13#include <linux/irqflags.h>
 14#include <linux/interrupt.h>
 15#include <linux/irq.h>
 16#include <asm/vtimer.h>
 17#include <asm/div64.h>
 18#include <asm/idle.h>
 19
 20void __delay(unsigned long loops)
 21{
 22        /*
 23         * To end the bloody studid and useless discussion about the
 24         * BogoMips number I took the liberty to define the __delay
 25         * function in a way that that resulting BogoMips number will
 26         * yield the megahertz number of the cpu. The important function
 27         * is udelay and that is done using the tod clock. -- martin.
 28         */
 29	asm volatile("0: brct %0,0b" : : "d" ((loops/2) + 1));
 30}
 31EXPORT_SYMBOL(__delay);
 32
 33static void __udelay_disabled(unsigned long long usecs)
 34{
 35	unsigned long cr0, cr0_new, psw_mask;
 36	struct s390_idle_data idle;
 37	u64 end;
 38
 39	end = get_tod_clock() + (usecs << 12);
 40	__ctl_store(cr0, 0, 0);
 41	cr0_new = cr0 & ~CR0_IRQ_SUBCLASS_MASK;
 42	cr0_new |= (1UL << (63 - 52)); /* enable clock comparator irq */
 43	__ctl_load(cr0_new, 0, 0);
 44	psw_mask = __extract_psw() | PSW_MASK_EXT | PSW_MASK_WAIT;
 45	set_clock_comparator(end);
 46	set_cpu_flag(CIF_IGNORE_IRQ);
 47	psw_idle(&idle, psw_mask);
 48	clear_cpu_flag(CIF_IGNORE_IRQ);
 49	set_clock_comparator(S390_lowcore.clock_comparator);
 50	__ctl_load(cr0, 0, 0);
 51}
 52
 53static void __udelay_enabled(unsigned long long usecs)
 54{
 55	u64 clock_saved, end;
 56
 57	end = get_tod_clock_fast() + (usecs << 12);
 58	do {
 59		clock_saved = 0;
 60		if (end < S390_lowcore.clock_comparator) {
 61			clock_saved = local_tick_disable();
 62			set_clock_comparator(end);
 63		}
 64		enabled_wait();
 65		if (clock_saved)
 66			local_tick_enable(clock_saved);
 67	} while (get_tod_clock_fast() < end);
 68}
 69
 70/*
 71 * Waits for 'usecs' microseconds using the TOD clock comparator.
 72 */
 73void __udelay(unsigned long long usecs)
 74{
 75	unsigned long flags;
 76
 77	preempt_disable();
 78	local_irq_save(flags);
 79	if (in_irq()) {
 80		__udelay_disabled(usecs);
 81		goto out;
 82	}
 83	if (in_softirq()) {
 84		if (raw_irqs_disabled_flags(flags))
 85			__udelay_disabled(usecs);
 86		else
 87			__udelay_enabled(usecs);
 88		goto out;
 89	}
 90	if (raw_irqs_disabled_flags(flags)) {
 91		local_bh_disable();
 92		__udelay_disabled(usecs);
 93		_local_bh_enable();
 94		goto out;
 95	}
 96	__udelay_enabled(usecs);
 97out:
 98	local_irq_restore(flags);
 99	preempt_enable();
100}
101EXPORT_SYMBOL(__udelay);
102
103/*
104 * Simple udelay variant. To be used on startup and reboot
105 * when the interrupt handler isn't working.
106 */
107void udelay_simple(unsigned long long usecs)
108{
109	u64 end;
110
111	end = get_tod_clock_fast() + (usecs << 12);
112	while (get_tod_clock_fast() < end)
113		cpu_relax();
114}
115
116void __ndelay(unsigned long long nsecs)
117{
118	u64 end;
119
120	nsecs <<= 9;
121	do_div(nsecs, 125);
122	end = get_tod_clock_fast() + nsecs;
123	if (nsecs & ~0xfffUL)
124		__udelay(nsecs >> 12);
125	while (get_tod_clock_fast() < end)
126		barrier();
127}
128EXPORT_SYMBOL(__ndelay);