mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-12-05 11:00:15 +00:00
236f2ec432
This commit does the same thing as Linux commit 33def8498fdd. Use a more generic form for __section that requires quotes to avoid complications with clang and gcc differences. Remove the quote operator # from compiler_attributes.h __section macro. Convert all unquoted __section(foo) uses to quoted __section("foo"). Also convert __attribute__((section("foo"))) uses to __section("foo") even if the __attribute__ has multiple list entry forms. Signed-off-by: Marek Behún <marek.behun@nic.cz> Reviewed-by: Bin Meng <bmeng.cn@gmail.com> Reviewed-by: Simon Glass <sjg@chromium.org>
299 lines
7.3 KiB
C
299 lines
7.3 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* (C) Copyright 2016 Nexell
|
|
* Hyunseok, Jung <hsjung@nexell.co.kr>
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <log.h>
|
|
|
|
#include <asm/io.h>
|
|
#include <asm/arch/nexell.h>
|
|
#include <asm/arch/clk.h>
|
|
#if defined(CONFIG_ARCH_S5P4418)
|
|
#include <asm/arch/reset.h>
|
|
#endif
|
|
|
|
#if (CONFIG_TIMER_SYS_TICK_CH > 3)
|
|
#error Not support timer channel. Please use "0~3" channels.
|
|
#endif
|
|
|
|
/* global variables to save timer count
|
|
*
|
|
* Section ".data" must be used because BSS is not available before relocation,
|
|
* in board_init_f(), respectively! I.e. global variables can not be used!
|
|
*/
|
|
static unsigned long timestamp __section(".data");
|
|
static unsigned long lastdec __section(".data");
|
|
static int timerinit __section(".data");
|
|
|
|
/* macro to hw timer tick config */
|
|
static long TIMER_FREQ = 1000000;
|
|
static long TIMER_HZ = 1000000 / CONFIG_SYS_HZ;
|
|
static long TIMER_COUNT = 0xFFFFFFFF;
|
|
|
|
#define REG_TCFG0 (0x00)
|
|
#define REG_TCFG1 (0x04)
|
|
#define REG_TCON (0x08)
|
|
#define REG_TCNTB0 (0x0C)
|
|
#define REG_TCMPB0 (0x10)
|
|
#define REG_TCNT0 (0x14)
|
|
#define REG_CSTAT (0x44)
|
|
|
|
#define TCON_BIT_AUTO (1 << 3)
|
|
#define TCON_BIT_INVT (1 << 2)
|
|
#define TCON_BIT_UP (1 << 1)
|
|
#define TCON_BIT_RUN (1 << 0)
|
|
#define TCFG0_BIT_CH(ch) ((ch) == 0 || (ch) == 1 ? 0 : 8)
|
|
#define TCFG1_BIT_CH(ch) ((ch) * 4)
|
|
#define TCON_BIT_CH(ch) ((ch) ? (ch) * 4 + 4 : 0)
|
|
#define TINT_CH(ch) (ch)
|
|
#define TINT_CSTAT_BIT_CH(ch) ((ch) + 5)
|
|
#define TINT_CSTAT_MASK (0x1F)
|
|
#define TIMER_TCNT_OFFS (0xC)
|
|
|
|
void reset_timer_masked(void);
|
|
unsigned long get_timer_masked(void);
|
|
|
|
/*
|
|
* Timer HW
|
|
*/
|
|
static inline void timer_clock(void __iomem *base, int ch, int mux, int scl)
|
|
{
|
|
u32 val = readl(base + REG_TCFG0) & ~(0xFF << TCFG0_BIT_CH(ch));
|
|
|
|
writel(val | ((scl - 1) << TCFG0_BIT_CH(ch)), base + REG_TCFG0);
|
|
val = readl(base + REG_TCFG1) & ~(0xF << TCFG1_BIT_CH(ch));
|
|
writel(val | (mux << TCFG1_BIT_CH(ch)), base + REG_TCFG1);
|
|
}
|
|
|
|
static inline void timer_count(void __iomem *base, int ch, unsigned int cnt)
|
|
{
|
|
writel((cnt - 1), base + REG_TCNTB0 + (TIMER_TCNT_OFFS * ch));
|
|
writel((cnt - 1), base + REG_TCMPB0 + (TIMER_TCNT_OFFS * ch));
|
|
}
|
|
|
|
static inline void timer_start(void __iomem *base, int ch)
|
|
{
|
|
int on = 0;
|
|
u32 val = readl(base + REG_CSTAT) & ~(TINT_CSTAT_MASK << 5 | 0x1 << ch);
|
|
|
|
writel(val | (0x1 << TINT_CSTAT_BIT_CH(ch) | on << ch),
|
|
base + REG_CSTAT);
|
|
val = readl(base + REG_TCON) & ~(0xE << TCON_BIT_CH(ch));
|
|
writel(val | (TCON_BIT_UP << TCON_BIT_CH(ch)), base + REG_TCON);
|
|
|
|
val &= ~(TCON_BIT_UP << TCON_BIT_CH(ch));
|
|
val |= ((TCON_BIT_AUTO | TCON_BIT_RUN) << TCON_BIT_CH(ch));
|
|
writel(val, base + REG_TCON);
|
|
dmb();
|
|
}
|
|
|
|
static inline void timer_stop(void __iomem *base, int ch)
|
|
{
|
|
int on = 0;
|
|
u32 val = readl(base + REG_CSTAT) & ~(TINT_CSTAT_MASK << 5 | 0x1 << ch);
|
|
|
|
writel(val | (0x1 << TINT_CSTAT_BIT_CH(ch) | on << ch),
|
|
base + REG_CSTAT);
|
|
val = readl(base + REG_TCON) & ~(TCON_BIT_RUN << TCON_BIT_CH(ch));
|
|
writel(val, base + REG_TCON);
|
|
}
|
|
|
|
static inline unsigned long timer_read(void __iomem *base, int ch)
|
|
{
|
|
unsigned long ret;
|
|
|
|
ret = TIMER_COUNT - readl(base + REG_TCNT0 + (TIMER_TCNT_OFFS * ch));
|
|
return ret;
|
|
}
|
|
|
|
int timer_init(void)
|
|
{
|
|
struct clk *clk = NULL;
|
|
char name[16] = "pclk";
|
|
int ch = CONFIG_TIMER_SYS_TICK_CH;
|
|
unsigned long rate, tclk = 0;
|
|
unsigned long mout, thz, cmp = -1UL;
|
|
int tcnt, tscl = 0, tmux = 0;
|
|
int mux = 0, scl = 0;
|
|
void __iomem *base = (void __iomem *)PHY_BASEADDR_TIMER;
|
|
|
|
if (timerinit)
|
|
return 0;
|
|
|
|
/* get with PCLK */
|
|
clk = clk_get(name);
|
|
rate = clk_get_rate(clk);
|
|
for (mux = 0; mux < 5; mux++) {
|
|
mout = rate / (1 << mux), scl = mout / TIMER_FREQ,
|
|
thz = mout / scl;
|
|
if (!(mout % TIMER_FREQ) && 256 > scl) {
|
|
tclk = thz, tmux = mux, tscl = scl;
|
|
break;
|
|
}
|
|
if (scl > 256)
|
|
continue;
|
|
if (abs(thz - TIMER_FREQ) >= cmp)
|
|
continue;
|
|
tclk = thz, tmux = mux, tscl = scl;
|
|
cmp = abs(thz - TIMER_FREQ);
|
|
}
|
|
tcnt = tclk; /* Timer Count := 1 Mhz counting */
|
|
|
|
TIMER_FREQ = tcnt; /* Timer Count := 1 Mhz counting */
|
|
TIMER_HZ = TIMER_FREQ / CONFIG_SYS_HZ;
|
|
tcnt = TIMER_COUNT == 0xFFFFFFFF ? TIMER_COUNT + 1 : tcnt;
|
|
|
|
timer_stop(base, ch);
|
|
timer_clock(base, ch, tmux, tscl);
|
|
timer_count(base, ch, tcnt);
|
|
timer_start(base, ch);
|
|
|
|
reset_timer_masked();
|
|
timerinit = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void reset_timer(void)
|
|
{
|
|
reset_timer_masked();
|
|
}
|
|
|
|
unsigned long get_timer(unsigned long base)
|
|
{
|
|
long ret;
|
|
unsigned long time = get_timer_masked();
|
|
unsigned long hz = TIMER_HZ;
|
|
|
|
ret = time / hz - base;
|
|
return ret;
|
|
}
|
|
|
|
void set_timer(unsigned long t)
|
|
{
|
|
timestamp = (unsigned long)t;
|
|
}
|
|
|
|
void reset_timer_masked(void)
|
|
{
|
|
void __iomem *base = (void __iomem *)PHY_BASEADDR_TIMER;
|
|
int ch = CONFIG_TIMER_SYS_TICK_CH;
|
|
|
|
/* reset time */
|
|
/* capure current decrementer value time */
|
|
lastdec = timer_read(base, ch);
|
|
/* start "advancing" time stamp from 0 */
|
|
timestamp = 0;
|
|
}
|
|
|
|
unsigned long get_timer_masked(void)
|
|
{
|
|
void __iomem *base = (void __iomem *)PHY_BASEADDR_TIMER;
|
|
int ch = CONFIG_TIMER_SYS_TICK_CH;
|
|
|
|
unsigned long now = timer_read(base, ch); /* current tick value */
|
|
|
|
if (now >= lastdec) { /* normal mode (non roll) */
|
|
/* move stamp fordward with absolute diff ticks */
|
|
timestamp += now - lastdec;
|
|
} else {
|
|
/* we have overflow of the count down timer */
|
|
/* nts = ts + ld + (TLV - now)
|
|
* ts=old stamp, ld=time that passed before passing through -1
|
|
* (TLV-now) amount of time after passing though -1
|
|
* nts = new "advancing time stamp"...
|
|
* it could also roll and cause problems.
|
|
*/
|
|
timestamp += now + TIMER_COUNT - lastdec;
|
|
}
|
|
/* save last */
|
|
lastdec = now;
|
|
|
|
debug("now=%lu, last=%lu, timestamp=%lu\n", now, lastdec, timestamp);
|
|
return (unsigned long)timestamp;
|
|
}
|
|
|
|
void __udelay(unsigned long usec)
|
|
{
|
|
unsigned long tmo, tmp;
|
|
|
|
debug("+udelay=%ld\n", usec);
|
|
|
|
if (!timerinit)
|
|
timer_init();
|
|
|
|
/* if "big" number, spread normalization to seconds */
|
|
if (usec >= 1000) {
|
|
/* start to normalize for usec to ticks per sec */
|
|
tmo = usec / 1000;
|
|
/* find number of "ticks" to wait to achieve target */
|
|
tmo *= TIMER_FREQ;
|
|
/* finish normalize. */
|
|
tmo /= 1000;
|
|
/* else small number, don't kill it prior to HZ multiply */
|
|
} else {
|
|
tmo = usec * TIMER_FREQ;
|
|
tmo /= (1000 * 1000);
|
|
}
|
|
|
|
tmp = get_timer_masked(); /* get current timestamp */
|
|
debug("A. tmo=%ld, tmp=%ld\n", tmo, tmp);
|
|
|
|
/* if setting this fordward will roll time stamp */
|
|
if (tmp > (tmo + tmp + 1))
|
|
/* reset "advancing" timestamp to 0, set lastdec value */
|
|
reset_timer_masked();
|
|
else
|
|
/* set advancing stamp wake up time */
|
|
tmo += tmp;
|
|
|
|
debug("B. tmo=%ld, tmp=%ld\n", tmo, tmp);
|
|
|
|
/* loop till event */
|
|
do {
|
|
tmp = get_timer_masked();
|
|
} while (tmo > tmp);
|
|
debug("-udelay=%ld\n", usec);
|
|
}
|
|
|
|
void udelay_masked(unsigned long usec)
|
|
{
|
|
unsigned long tmo, endtime;
|
|
signed long diff;
|
|
|
|
/* if "big" number, spread normalization to seconds */
|
|
if (usec >= 1000) {
|
|
/* start to normalize for usec to ticks per sec */
|
|
tmo = usec / 1000;
|
|
/* find number of "ticks" to wait to achieve target */
|
|
tmo *= TIMER_FREQ;
|
|
/* finish normalize. */
|
|
tmo /= 1000;
|
|
} else { /* else small number, don't kill it prior to HZ multiply */
|
|
tmo = usec * TIMER_FREQ;
|
|
tmo /= (1000 * 1000);
|
|
}
|
|
|
|
endtime = get_timer_masked() + tmo;
|
|
|
|
do {
|
|
unsigned long now = get_timer_masked();
|
|
|
|
diff = endtime - now;
|
|
} while (diff >= 0);
|
|
}
|
|
|
|
unsigned long long get_ticks(void)
|
|
{
|
|
return get_timer_masked();
|
|
}
|
|
|
|
#if defined(CONFIG_ARCH_S5P4418)
|
|
ulong get_tbclk(void)
|
|
{
|
|
ulong tbclk = TIMER_FREQ;
|
|
return tbclk;
|
|
}
|
|
#endif
|