2017-01-26 15:51:33 +01:00
|
|
|
/*
|
2018-10-23 09:08:58 -07:00
|
|
|
* Copyright (c) 2018 Intel Corporation
|
|
|
|
|
*
|
2017-01-26 15:51:33 +01:00
|
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
|
|
|
*/
|
2021-11-04 12:51:39 +01:00
|
|
|
#include <device.h>
|
2019-06-21 12:55:37 -04:00
|
|
|
#include <drivers/timer/system_timer.h>
|
2018-10-23 09:08:58 -07:00
|
|
|
#include <sys_clock.h>
|
|
|
|
|
#include <spinlock.h>
|
2017-01-26 15:51:33 +01:00
|
|
|
|
2018-10-23 09:08:58 -07:00
|
|
|
#define TIMER_IRQ UTIL_CAT(XCHAL_TIMER, \
|
|
|
|
|
UTIL_CAT(CONFIG_XTENSA_TIMER_ID, _INTERRUPT))
|
2017-10-27 21:38:42 +05:30
|
|
|
|
2019-04-23 15:08:00 +02:00
|
|
|
#define CYC_PER_TICK (sys_clock_hw_cycles_per_sec() \
|
2018-10-23 09:08:58 -07:00
|
|
|
/ CONFIG_SYS_CLOCK_TICKS_PER_SEC)
|
2019-11-26 11:27:19 -08:00
|
|
|
#define MAX_CYC 0xffffffffu
|
|
|
|
|
#define MAX_TICKS ((MAX_CYC - CYC_PER_TICK) / CYC_PER_TICK)
|
2018-10-23 09:08:58 -07:00
|
|
|
#define MIN_DELAY 1000
|
2017-10-27 21:38:42 +05:30
|
|
|
|
2018-10-23 09:08:58 -07:00
|
|
|
static struct k_spinlock lock;
|
|
|
|
|
static unsigned int last_count;
|
2017-10-27 21:38:42 +05:30
|
|
|
|
2020-05-27 11:26:57 -05:00
|
|
|
static void set_ccompare(uint32_t val)
|
2017-10-27 21:38:42 +05:30
|
|
|
{
|
2018-10-23 09:08:58 -07:00
|
|
|
__asm__ volatile ("wsr.CCOMPARE" STRINGIFY(CONFIG_XTENSA_TIMER_ID) " %0"
|
|
|
|
|
:: "r"(val));
|
2017-10-27 21:38:42 +05:30
|
|
|
}
|
|
|
|
|
|
2020-05-27 11:26:57 -05:00
|
|
|
static uint32_t ccount(void)
|
2017-10-27 21:38:42 +05:30
|
|
|
{
|
2020-05-27 11:26:57 -05:00
|
|
|
uint32_t val;
|
2017-10-27 21:38:42 +05:30
|
|
|
|
2018-10-23 09:08:58 -07:00
|
|
|
__asm__ volatile ("rsr.CCOUNT %0" : "=r"(val));
|
|
|
|
|
return val;
|
2017-10-27 21:38:42 +05:30
|
|
|
}
|
|
|
|
|
|
isr: Normalize usage of device instance through ISR
The goal of this patch is to replace the 'void *' parameter by 'struct
device *' if they use such variable or just 'const void *' on all
relevant ISRs
This will avoid not-so-nice const qualifier tweaks when device instances
will be constant.
Note that only the ISR passed to IRQ_CONNECT are of interest here.
In order to do so, the script fix_isr.py below is necessary:
from pathlib import Path
import subprocess
import pickle
import mmap
import sys
import re
import os
cocci_template = """
@r_fix_isr_0
@
type ret_type;
identifier P;
identifier D;
@@
-ret_type <!fn!>(void *P)
+ret_type <!fn!>(const struct device *P)
{
...
(
const struct device *D = (const struct device *)P;
|
const struct device *D = P;
)
...
}
@r_fix_isr_1
@
type ret_type;
identifier P;
identifier D;
@@
-ret_type <!fn!>(void *P)
+ret_type <!fn!>(const struct device *P)
{
...
const struct device *D;
...
(
D = (const struct device *)P;
|
D = P;
)
...
}
@r_fix_isr_2
@
type ret_type;
identifier A;
@@
-ret_type <!fn!>(void *A)
+ret_type <!fn!>(const void *A)
{
...
}
@r_fix_isr_3
@
const struct device *D;
@@
-<!fn!>((void *)D);
+<!fn!>(D);
@r_fix_isr_4
@
type ret_type;
identifier D;
identifier P;
@@
-ret_type <!fn!>(const struct device *P)
+ret_type <!fn!>(const struct device *D)
{
...
(
-const struct device *D = (const struct device *)P;
|
-const struct device *D = P;
)
...
}
@r_fix_isr_5
@
type ret_type;
identifier D;
identifier P;
@@
-ret_type <!fn!>(const struct device *P)
+ret_type <!fn!>(const struct device *D)
{
...
-const struct device *D;
...
(
-D = (const struct device *)P;
|
-D = P;
)
...
}
"""
def find_isr(fn):
db = []
data = None
start = 0
try:
with open(fn, 'r+') as f:
data = str(mmap.mmap(f.fileno(), 0).read())
except Exception as e:
return db
while True:
isr = ""
irq = data.find('IRQ_CONNECT', start)
while irq > -1:
p = 1
arg = 1
p_o = data.find('(', irq)
if p_o < 0:
irq = -1
break;
pos = p_o + 1
while p > 0:
if data[pos] == ')':
p -= 1
elif data[pos] == '(':
p += 1
elif data[pos] == ',' and p == 1:
arg += 1
if arg == 3:
isr += data[pos]
pos += 1
isr = isr.strip(',\\n\\t ')
if isr not in db and len(isr) > 0:
db.append(isr)
start = pos
break
if irq < 0:
break
return db
def patch_isr(fn, isr_list):
if len(isr_list) <= 0:
return
for isr in isr_list:
tmplt = cocci_template.replace('<!fn!>', isr)
with open('/tmp/isr_fix.cocci', 'w') as f:
f.write(tmplt)
cmd = ['spatch', '--sp-file', '/tmp/isr_fix.cocci', '--in-place', fn]
subprocess.run(cmd)
def process_files(path):
if path.is_file() and path.suffix in ['.h', '.c']:
p = str(path.parent) + '/' + path.name
isr_list = find_isr(p)
patch_isr(p, isr_list)
elif path.is_dir():
for p in path.iterdir():
process_files(p)
if len(sys.argv) < 2:
print("You need to provide a dir/file path")
sys.exit(1)
process_files(Path(sys.argv[1]))
And is run: ./fix_isr.py <zephyr root directory>
Finally, some files needed manual fixes such.
Fixes #27399
Signed-off-by: Tomasz Bursztyka <tomasz.bursztyka@linux.intel.com>
2020-06-17 14:58:56 +02:00
|
|
|
static void ccompare_isr(const void *arg)
|
2017-10-27 21:38:42 +05:30
|
|
|
{
|
2018-10-23 09:08:58 -07:00
|
|
|
ARG_UNUSED(arg);
|
2017-10-27 21:38:42 +05:30
|
|
|
|
2018-10-23 09:08:58 -07:00
|
|
|
k_spinlock_key_t key = k_spin_lock(&lock);
|
2020-05-27 11:26:57 -05:00
|
|
|
uint32_t curr = ccount();
|
|
|
|
|
uint32_t dticks = (curr - last_count) / CYC_PER_TICK;
|
2017-10-27 21:38:42 +05:30
|
|
|
|
2018-10-23 09:08:58 -07:00
|
|
|
last_count += dticks * CYC_PER_TICK;
|
2017-10-27 21:38:42 +05:30
|
|
|
|
2020-05-12 10:32:40 +08:00
|
|
|
if (!IS_ENABLED(CONFIG_TICKLESS_KERNEL)) {
|
2020-05-27 11:26:57 -05:00
|
|
|
uint32_t next = last_count + CYC_PER_TICK;
|
2017-10-27 21:38:42 +05:30
|
|
|
|
2020-05-27 11:26:57 -05:00
|
|
|
if ((int32_t)(next - curr) < MIN_DELAY) {
|
2018-10-23 09:08:58 -07:00
|
|
|
next += CYC_PER_TICK;
|
|
|
|
|
}
|
|
|
|
|
set_ccompare(next);
|
2017-10-27 21:38:42 +05:30
|
|
|
}
|
|
|
|
|
|
2018-10-23 09:08:58 -07:00
|
|
|
k_spin_unlock(&lock, key);
|
2021-02-25 15:33:15 -05:00
|
|
|
sys_clock_announce(IS_ENABLED(CONFIG_TICKLESS_KERNEL) ? dticks : 1);
|
2017-10-27 21:38:42 +05:30
|
|
|
}
|
2017-01-26 15:51:33 +01:00
|
|
|
|
2021-02-25 15:33:15 -05:00
|
|
|
void sys_clock_set_timeout(int32_t ticks, bool idle)
|
2017-01-26 15:51:33 +01:00
|
|
|
{
|
2018-10-23 09:08:58 -07:00
|
|
|
ARG_UNUSED(idle);
|
2017-01-26 15:51:33 +01:00
|
|
|
|
2020-05-12 10:32:40 +08:00
|
|
|
#if defined(CONFIG_TICKLESS_KERNEL)
|
kernel/timeout: Make timeout arguments an opaque type
Add a k_timeout_t type, and use it everywhere that kernel API
functions were accepting a millisecond timeout argument. Instead of
forcing milliseconds everywhere (which are often not integrally
representable as system ticks), do the conversion to ticks at the
point where the timeout is created. This avoids an extra unit
conversion in some application code, and allows us to express the
timeout in units other than milliseconds to achieve greater precision.
The existing K_MSEC() et. al. macros now return initializers for a
k_timeout_t.
The K_NO_WAIT and K_FOREVER constants have now become k_timeout_t
values, which means they cannot be operated on as integers.
Applications which have their own APIs that need to inspect these
vs. user-provided timeouts can now use a K_TIMEOUT_EQ() predicate to
test for equality.
Timer drivers, which receive an integer tick count in ther
z_clock_set_timeout() functions, now use the integer-valued
K_TICKS_FOREVER constant instead of K_FOREVER.
For the initial release, to preserve source compatibility, a
CONFIG_LEGACY_TIMEOUT_API kconfig is provided. When true, the
k_timeout_t will remain a compatible 32 bit value that will work with
any legacy Zephyr application.
Some subsystems present timeout (or timeout-like) values to their own
users as APIs that would re-use the kernel's own constants and
conventions. These will require some minor design work to adapt to
the new scheme (in most cases just using k_timeout_t directly in their
own API), and they have not been changed in this patch, instead
selecting CONFIG_LEGACY_TIMEOUT_API via kconfig. These subsystems
include: CAN Bus, the Microbit display driver, I2S, LoRa modem
drivers, the UART Async API, Video hardware drivers, the console
subsystem, and the network buffer abstraction.
k_sleep() now takes a k_timeout_t argument, with a k_msleep() variant
provided that works identically to the original API.
Most of the changes here are just type/configuration management and
documentation, but there are logic changes in mempool, where a loop
that used a timeout numerically has been reworked using a new
z_timeout_end_calc() predicate. Also in queue.c, a (when POLL was
enabled) a similar loop was needlessly used to try to retry the
k_poll() call after a spurious failure. But k_poll() does not fail
spuriously, so the loop was removed.
Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2020-03-05 15:18:14 -08:00
|
|
|
ticks = ticks == K_TICKS_FOREVER ? MAX_TICKS : ticks;
|
2020-10-27 12:27:25 +01:00
|
|
|
ticks = CLAMP(ticks - 1, 0, (int32_t)MAX_TICKS);
|
2017-01-26 15:51:33 +01:00
|
|
|
|
2018-10-23 09:08:58 -07:00
|
|
|
k_spinlock_key_t key = k_spin_lock(&lock);
|
2020-05-27 11:26:57 -05:00
|
|
|
uint32_t curr = ccount(), cyc, adj;
|
2017-01-26 15:51:33 +01:00
|
|
|
|
2018-10-23 09:08:58 -07:00
|
|
|
/* Round up to next tick boundary */
|
2019-11-26 11:27:19 -08:00
|
|
|
cyc = ticks * CYC_PER_TICK;
|
|
|
|
|
adj = (curr - last_count) + (CYC_PER_TICK - 1);
|
|
|
|
|
if (cyc <= MAX_CYC - adj) {
|
|
|
|
|
cyc += adj;
|
|
|
|
|
} else {
|
|
|
|
|
cyc = MAX_CYC;
|
|
|
|
|
}
|
2018-10-23 09:08:58 -07:00
|
|
|
cyc = (cyc / CYC_PER_TICK) * CYC_PER_TICK;
|
|
|
|
|
cyc += last_count;
|
2017-01-26 15:51:33 +01:00
|
|
|
|
2018-10-23 09:08:58 -07:00
|
|
|
if ((cyc - curr) < MIN_DELAY) {
|
|
|
|
|
cyc += CYC_PER_TICK;
|
2017-01-26 15:51:33 +01:00
|
|
|
}
|
2018-11-02 13:24:28 -07:00
|
|
|
|
2018-10-23 09:08:58 -07:00
|
|
|
set_ccompare(cyc);
|
|
|
|
|
k_spin_unlock(&lock, key);
|
2017-12-14 13:21:12 -08:00
|
|
|
#endif
|
2017-01-26 15:51:33 +01:00
|
|
|
}
|
|
|
|
|
|
2021-02-25 15:33:15 -05:00
|
|
|
uint32_t sys_clock_elapsed(void)
|
2017-01-26 15:51:33 +01:00
|
|
|
{
|
2018-10-23 09:08:58 -07:00
|
|
|
if (!IS_ENABLED(CONFIG_TICKLESS_KERNEL)) {
|
|
|
|
|
return 0;
|
2017-10-27 21:38:42 +05:30
|
|
|
}
|
2018-07-23 13:49:26 +05:30
|
|
|
|
2018-10-23 09:08:58 -07:00
|
|
|
k_spinlock_key_t key = k_spin_lock(&lock);
|
2020-05-27 11:26:57 -05:00
|
|
|
uint32_t ret = (ccount() - last_count) / CYC_PER_TICK;
|
2017-01-26 15:51:33 +01:00
|
|
|
|
2018-10-23 09:08:58 -07:00
|
|
|
k_spin_unlock(&lock, key);
|
|
|
|
|
return ret;
|
2017-01-26 15:51:33 +01:00
|
|
|
}
|
|
|
|
|
|
2021-03-12 12:46:52 -05:00
|
|
|
uint32_t sys_clock_cycle_get_32(void)
|
2017-01-26 15:51:33 +01:00
|
|
|
{
|
2018-10-23 09:08:58 -07:00
|
|
|
return ccount();
|
2017-01-26 15:51:33 +01:00
|
|
|
}
|
2019-01-28 09:12:13 -08:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
void smp_timer_init(void)
|
|
|
|
|
{
|
|
|
|
|
set_ccompare(ccount() + CYC_PER_TICK);
|
|
|
|
|
irq_enable(TIMER_IRQ);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2021-11-04 12:51:39 +01:00
|
|
|
|
|
|
|
|
static int sys_clock_driver_init(const struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
ARG_UNUSED(dev);
|
|
|
|
|
|
|
|
|
|
IRQ_CONNECT(TIMER_IRQ, 0, ccompare_isr, 0, 0);
|
|
|
|
|
set_ccompare(ccount() + CYC_PER_TICK);
|
|
|
|
|
irq_enable(TIMER_IRQ);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
SYS_INIT(sys_clock_driver_init, PRE_KERNEL_2,
|
|
|
|
|
CONFIG_SYSTEM_CLOCK_INIT_PRIORITY);
|
