arch/m68k/include/asm/delay.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _M68K_DELAY_H
   3 #define _M68K_DELAY_H
   4
   5 #include <asm/param.h>
   6
   7 /*
   8  * Copyright (C) 1994 Hamish Macdonald
   9  * Copyright (C) 2004 Greg Ungerer <gerg@uclinux.com>
  10  *
  11  * Delay routines, using a pre-computed "loops_per_jiffy" value.
  12  */
  13
  14 #if defined(CONFIG_COLDFIRE)
  15 /*
  16  * The ColdFire runs the delay loop at significantly different speeds
  17  * depending upon long word alignment or not.  We'll pad it to
  18  * long word alignment which is the faster version.
  19  * The 0x4a8e is of course a 'tstl %fp' instruction.  This is better
  20  * than using a NOP (0x4e71) instruction because it executes in one
  21  * cycle not three and doesn't allow for an arbitrary delay waiting
  22  * for bus cycles to finish.  Also fp/a6 isn't likely to cause a
  23  * stall waiting for the register to become valid if such is added
  24  * to the coldfire at some stage.
  25  */
  26 #define DELAY_ALIGN     ".balignw 4, 0x4a8e\n\t"
  27 #else
  28 /*
  29  * No instruction alignment required for other m68k types.
  30  */
  31 #define DELAY_ALIGN
  32 #endif
  33
  34 static inline void __delay(unsigned long loops)
  35 {
  36         __asm__ __volatile__ (
  37                 DELAY_ALIGN
  38                 "1: subql #1,%0\n\t"
  39                 "jcc 1b"
  40                 : "=d" (loops)
  41                 : "0" (loops));
  42 }
  43
  44 extern void __bad_udelay(void);
  45
  46
  47 #ifdef CONFIG_CPU_HAS_NO_MULDIV64
  48 /*
  49  * The simpler m68k and ColdFire processors do not have a 32*32->64
  50  * multiply instruction. So we need to handle them a little differently.
  51  * We use a bit of shifting and a single 32*32->32 multiply to get close.
  52  * This is a macro so that the const version can factor out the first
  53  * multiply and shift.
  54  */
  55 #define HZSCALE         (268435456 / (1000000 / HZ))
  56
  57 #define __const_udelay(u) \
  58         __delay(((((u) * HZSCALE) >> 11) * (loops_per_jiffy >> 11)) >> 6)
  59
  60 #else
  61
  62 static inline void __xdelay(unsigned long xloops)
  63 {
  64         unsigned long tmp;
  65
  66         __asm__ ("mulul %2,%0:%1"
  67                 : "=d" (xloops), "=d" (tmp)
  68                 : "d" (xloops), "1" (loops_per_jiffy));
  69         __delay(xloops * HZ);
  70 }
  71
  72 /*
  73  * The definition of __const_udelay is specifically made a macro so that
  74  * the const factor (4295 = 2**32 / 1000000) can be optimized out when
  75  * the delay is a const.
  76  */
  77 #define __const_udelay(n)       (__xdelay((n) * 4295))
  78
  79 #endif
  80
  81 static inline void __udelay(unsigned long usecs)
  82 {
  83         __const_udelay(usecs);
  84 }
  85
  86 /*
  87  * Use only for very small delays ( < 1 msec).  Should probably use a
  88  * lookup table, really, as the multiplications take much too long with
  89  * short delays.  This is a "reasonable" implementation, though (and the
  90  * first constant multiplications gets optimized away if the delay is
  91  * a constant)
  92  */
  93 #define udelay(n) (__builtin_constant_p(n) ? \
  94         ((n) > 20000 ? __bad_udelay() : __const_udelay(n)) : __udelay(n))
  95
  96 /*
  97  * nanosecond delay:
  98  *
  99  * ((((HZSCALE) >> 11) * (loops_per_jiffy >> 11)) >> 6) is the number of loops
 100  * per microsecond
 101  *
 102  * 1000 / ((((HZSCALE) >> 11) * (loops_per_jiffy >> 11)) >> 6) is the number of
 103  * nanoseconds per loop
 104  *
 105  * So n / ( 1000 / ((((HZSCALE) >> 11) * (loops_per_jiffy >> 11)) >> 6) ) would
 106  * be the number of loops for n nanoseconds
 107  */
 108
 109 /*
 110  * The simpler m68k and ColdFire processors do not have a 32*32->64
 111  * multiply instruction. So we need to handle them a little differently.
 112  * We use a bit of shifting and a single 32*32->32 multiply to get close.
 113  * This is a macro so that the const version can factor out the first
 114  * multiply and shift.
 115  */
 116 #define HZSCALE         (268435456 / (1000000 / HZ))
 117
 118 #define ndelay(n) __delay(DIV_ROUND_UP((n) * ((((HZSCALE) >> 11) * (loops_per_jiffy >> 11)) >> 6), 1000))
 119
 120 #endif /* defined(_M68K_DELAY_H) */