| /Zephyr-Core-3.6.0/samples/subsys/pm/latency/ |
| D | sample.yaml | 15 - "<inf> app: Sleeping for 1.1 seconds, we should enter RUNTIME_IDLE"
17 - "<inf> app: Sleeping for 1.2 seconds, we should enter SUSPEND_TO_IDLE"
19 - "<inf> app: Sleeping for 1.3 seconds, we should enter STANDBY"
22 - "<inf> app: Sleeping for 1.1 seconds, we should enter RUNTIME_IDLE"
24 - "<inf> app: Sleeping for 1.2 seconds, we should enter SUSPEND_TO_IDLE"
26 - "<inf> app: Sleeping for 1.3 seconds, we should enter SUSPEND_TO_IDLE"
31 - "<inf> app: Sleeping for 1.1 seconds, we should enter RUNTIME_IDLE"
33 - "<inf> app: Sleeping for 1.2 seconds, we should enter RUNTIME_IDLE"
35 - "<inf> app: Sleeping for 1.3 seconds, we should enter RUNTIME_IDLE"
40 - "<inf> app: Sleeping for 1.1 seconds, we should stay ACTIVE"
[all …]
|
| /Zephyr-Core-3.6.0/samples/subsys/pm/latency/src/ |
| D | main.c | 41 LOG_INF("Sleeping for 1.1 seconds, we should enter RUNTIME_IDLE"); in main()
43 LOG_INF("Sleeping for 1.2 seconds, we should enter SUSPEND_TO_IDLE"); in main()
45 LOG_INF("Sleeping for 1.3 seconds, we should enter STANDBY"); in main()
53 LOG_INF("Sleeping for 1.1 seconds, we should enter RUNTIME_IDLE"); in main()
55 LOG_INF("Sleeping for 1.2 seconds, we should enter SUSPEND_TO_IDLE"); in main()
57 LOG_INF("Sleeping for 1.3 seconds, we should enter SUSPEND_TO_IDLE"); in main()
65 LOG_INF("Sleeping for 1.1 seconds, we should enter RUNTIME_IDLE"); in main()
67 LOG_INF("Sleeping for 1.2 seconds, we should enter RUNTIME_IDLE"); in main()
69 LOG_INF("Sleeping for 1.3 seconds, we should enter RUNTIME_IDLE"); in main()
77 LOG_INF("Sleeping for 1.1 seconds, we should stay ACTIVE"); in main()
[all …]
|
| /Zephyr-Core-3.6.0/arch/nios2/core/ |
| D | exception.S | 31 * If the External (EIC) controller is in use, then we will never get here on
68 /* Figure out whether we are here because of an interrupt or an
78 /* We stashed estatus in et earlier */
83 /* If we get here, this is an interrupt */
85 /* Grab a reference to _kernel in r10 so we can determine the
91 /* Stash a copy of thread's sp in r12 so that we can put it on the IRQ
106 * function parameter since we put it in r4
135 /* We put the thread stack pointer on top of the IRQ stack before
136 * we switched stacks. Restore it to go back to thread stack
142 * out of the context switch we need this info to restore
[all …]
|
| /Zephyr-Core-3.6.0/include/zephyr/arch/x86/ |
| D | memmap.h | 12 * The "source" of the memory map refers to where we got the data to fill in
27 * For simplicity, we maintain a fixed-sized array of memory regions.
29 * We don't only track available RAM -- we track unavailable regions, too:
30 * sometimes we'll be given a map with overlapping regions. We have to be
59 * We keep track of kernel memory areas (text, data, etc.) in a table for
|
| /Zephyr-Core-3.6.0/share/zephyr-package/cmake/ |
| D | ZephyrConfigVersion.cmake | 10 # Version 0.0.0 indicates that we should just return, in order to obtain our path.
18 # We are just a candidate, meaning we have been included from other installed module.
56 # We are the Zephyr to be used
65 # We are included, so we need to ensure that the version of the top-level
71 # When Zephyr base is set and we are checked as an included file
72 # (IS_INCLUDED=True), then we are unable to retrieve the version of the
101 # Do we share common index, if so, this is the correct version to check.
111 # Only do this if we are an installed CMake Config package and checking for workspace candidates.
120 # We are the best candidate, so let's check our own version.
128 # As this code is processed inside registered packages, we simply test if
[all …]
|
| /Zephyr-Core-3.6.0/tests/bsim/bluetooth/host/gatt/settings/src/ |
| D | client.c | 30 /* subscribe to the SC indication, so we don't have to ATT read to in client_round_0()
36 /* We should normally wait until we are bonded to write the CCC / CF in client_round_0()
37 * characteristics, but here we bond after the fact on purpose, to in client_round_0()
56 /* server should remember we are change-aware */ in client_round_1()
72 /* We are change-unaware. wait until the Service Changed indication is in client_round_2()
78 /* We sleep just enough so that the server's `delayed store` work item in client_round_2()
79 * is executed. We still trigger a disconnect, even though the server in client_round_2()
97 /* server should remember we are change-aware */ in client_round_3()
102 * In the next round, we will be change-unaware, so the first ATT read in client_round_3()
103 * will fail, but the second one will succeed and we will be marked as in client_round_3()
|
| D | server.c | 71 * NVS. We still have to wait for the delayed work to be run. in server_round_2()
138 * peer has disconnected. In round 2 we also make sure we receive the Service
142 * writes the change-awareness before we get disconnected. Basically, this
146 * Round 3 -> 4: same as (1->2), except this time we won't get the SC indication
147 * (as we have unsubscribed from it). We should instead get the
152 * This is a non-regression test to make sure we didn't break the previous
155 * Round 5 -> 6: tests DFU corner case: in this case, we are on the first boot
157 * reason, we decide to reboot before the delayed store work item has had the
159 * makes sure that we are indeed change-unaware.
169 /* Use the same public address for all instances of the central. If we in server_procedure()
|
| /Zephyr-Core-3.6.0/cmake/compiler/arcmwdt/ |
| D | target.cmake | 28 # (check_c_compiler_flag function which we wrap with target_cc_option in extensions.cmake)
29 # we rely on default MWDT header locations and don't manually specify headers directories.
36 # We can't rely on these functions presence if we don't use MWDT libc.
37 # NOTE: the option name '-fno-builtin' is misleading a bit - we still can
38 # manually call __builtin_** functions even if we specify it.
|
| /Zephyr-Core-3.6.0/arch/x86/core/intel64/ |
| D | userspace.S | 15 * to the user page table, and only then 'iret'. We jump to this instead
74 * moment we have no free registers or stack to save it to. This
75 * eventually gets put on the stack before we re-enable interrupts
81 /* We need to switch to the trampoline stack so that we can
101 /* We're now on the privilege mode stack; push the old user stack
126 * We save caller-saved registers so we can restore to original values
127 * when we call 'sysretq' at the end.
142 * we had to put in r10 instead of RCX
159 * RDI, RSI, RDX, R8, R9, R10, XMM* after we have serviced the system
160 * call. We saved them earlier, restore their original values when
[all …]
|
| /Zephyr-Core-3.6.0/tests/kernel/device/src/ |
| D | mmio.c | 38 /* fake API pointer, we don't use it at all for this suite */
47 * We show that we can make mapping calls and that the address returned by
51 * We also perform some checks depending on configuration:
56 * point to the same address. We show that no extra memory is used in
79 * The best we can check with 'regs' is that it's nonzero, as if in ZTEST()
81 * place it at. We don't otherwise look at `regs`; other tests will in ZTEST()
141 * We show that we can make mapping calls and that the address returned by
145 * We show that this works for a device instance that has two named regions,
148 * We also perform some checks depending on configuration:
153 * point to the same address. We show that no extra memory is used in
[all …]
|
| /Zephyr-Core-3.6.0/arch/xtensa/include/ |
| D | xtensa_asm2_s.h | 194 * (PTEVADDR base, the one mapping 0x00000000) so that we can
195 * use this to obtain the virtual address of the PTE page we are
200 * miss if we are to use l32r to load the PTEVADDR base.
202 * not in TLB, we will need to handle the TLB miss which
203 * we are trying to avoid here.
226 * is problematic when we are in the middle of dealing with another
227 * exception or handling an interrupt. So we need to put the PTE page
245 * 1. We need to find the virtual address of the PTE page
247 * register ADDR_REG. To do this, we first need to find
255 * we divide the address obtained in step (a) by
[all …]
|
| /Zephyr-Core-3.6.0/subsys/bluetooth/controller/ll_sw/openisa/hal/RV32M1/ |
| D | ll_irqs.h | 13 * LPTMR1 -> INTMUX_CH2. We expect it to be the only IRQ source for this channel
14 * We'll use the INTMUX ISR for channel 2 instead of LPTMR1 ISR
20 * radio -> INTMUX_CH3. We expect it to be the only IRQ source for this channel
21 * We'll use the INTMUX ISR for channel 3 instead of radio ISR
|
| /Zephyr-Core-3.6.0/arch/arm64/core/ |
| D | fpu.c | 101 /* search all CPUs for the owner we want */ in flush_owned_fpu()
108 /* we found it live on CPU i */ in flush_owned_fpu()
120 * we would be stuck here. in flush_owned_fpu()
123 * CPU, then we preemptively flush any live context in flush_owned_fpu()
124 * on this CPU as well since we're likely to in flush_owned_fpu()
156 * FPU access is disabled and we're trapped while in exception context.
158 * just to let the corresponding STR instructions execute, we simply
166 * We know there is no saved FPU context to check nor any in simulate_str_q_insn()
181 * We're looking for STR (immediate, SIMD&FP) of the form: in simulate_str_q_insn()
200 /* did we do something? */ in simulate_str_q_insn()
[all …]
|
| /Zephyr-Core-3.6.0/boards/posix/nrf_bsim/ |
| D | ipc_backend.c | 8 * Here we define the shared memory buffers for the RPMSG IPC back-end in simulation.
10 * In this simulated target, we just define them at build time to have the size defined
14 * when the network core is built with the IPC service, we cannot produce an executable
15 * with the network core image alone, as we would lack this buffer during linking.
|
| /Zephyr-Core-3.6.0/samples/net/mdns_responder/ |
| D | overlay-vlan.conf | 3 # We have one non-vlan interface and two VLAN interfaces
30 # Each interface needs at least 2 context. So if we have three
31 # interfaces we need minimum 6 context but allocate more so that
32 # we do not run out of them.
|
| /Zephyr-Core-3.6.0/cmake/modules/ |
| D | west.cmake | 7 # west is an optional dependency. We need to run west using the same
8 # Python interpreter as everything else, though, so we play some extra
12 # it's defined, we assume west is installed. We do these checks here
20 # If realpaths differ from the variables we're using, add extra
57 # WEST_PYTHON is undefined and we couldn't import west. That's
62 # We can import west from PYTHON_EXECUTABLE and have its version.
79 # Print information about the west module we're relying on. This
|
| /Zephyr-Core-3.6.0/samples/userspace/prod_consumer/src/ |
| D | app_b.c | 28 * we ensure all this gets linked into the continuous region denoted by
59 /* pretend we're doing something complicated and useful in processor_thread()
81 /* Much like how we are reusing the main thread as this application's in app_b_entry()
82 * processor thread, we will re-use the default memory domain as the in app_b_entry()
106 /* We are about to drop to user mode and become the monitor thread. in app_b_entry()
107 * Grant ourselves access to the kernel objects we need for in app_b_entry()
110 * In this case, we need access to both shared queue objects. We in app_b_entry()
|
| /Zephyr-Core-3.6.0/arch/arc/core/ |
| D | regular_irq.S | 36 1. We return from IRQ handler to a cooperative thread
59 | STATUS32 value, we explicitly save it here for later usage, read-on
70 thread's stack right on top of pre-switch contents so that's what we have:
96 So how do we return in such a complex scenario.
98 First we restore callee-saved regs with help of _load_callee_saved_regs().
99 Now we're back to PRE-CONTEXT-SWITCH STACK (see above).
103 we're still in interrupt handling mode and the only way to return to normal
104 execution mode is to execute "rtie" instruction. And here we need to deal
118 an interrupt, but remember we're returning to the thread which was
121 will happen. So if we do nothing special we'll end-up with that:
[all …]
|
| /Zephyr-Core-3.6.0/arch/xtensa/core/ |
| D | userspace.S | 76 * We need to increment it to execute the next instruction when
77 * we return. The instruction size is 3 bytes, so lets just add it.
100 * we are in a interruption we don't want the system
115 /* Set syscall parameters. We have an initial call4 to set up the
127 /* Since we are unmasking EXCM, we need to set RING bits to kernel
128 * mode, otherwise we won't be able to run the exception handler in C.
147 /* We want an ENTRY to set a bit in windowstart */
214 * do the rotation, but we are going to set our own
219 /* We have to switch to kernel stack before spill kernel data and
257 /* Set now z_thread_entry parameters, we are simulating a call4
[all …]
|
| /Zephyr-Core-3.6.0/arch/arc/ |
| D | CMakeLists.txt | 18 # For ARCv2 the default register is usually not specified - so we need to specify it
19 # For ARCv3 the register is fixed to r30, so we don't need to specify it
22 # If thread local storage isn't used - we can safely schedule thread pointer register
34 # Instruct MWDT assembler not to warn when we load only lower half (32bit) of symbol
35 # instead of full 64bit address in ASM code. It is valid as we don't support Zephyr
|
| /Zephyr-Core-3.6.0/tests/kernel/sleep/src/ |
| D | usleep.c | 12 * if the test passes at least once, we know it works properly, so we
19 * We need to know how many ticks will elapse when we ask for the
44 * Theory of operation: we can't use absolute units (e.g., "sleep for
47 * configuration. Instead, we test that k_usleep() actually sleeps for
49 * we loop k_usleep()ing for as many iterations as should comprise a
|
| /Zephyr-Core-3.6.0/tests/bsim/bluetooth/ll/ |
| D | _compile_permutate_kconfigs.sh | 41 # We set a unique exe-name, so that we don't overwrite the executables
43 # We also delete the executable to avoid having artifacts from
68 # Note: we need to call '_compile' instead of 'compile' because the latter starts
69 # compilations in parallel, but here we need to do it in serial since we modify
88 # We set exit code based on type of failure
|
| /Zephyr-Core-3.6.0/arch/posix/core/ |
| D | posix_core.c | 11 * We isolate all functions here, to ensure they can be compiled as
74 * (we only need 1 mutex and 1 cond variable for all threads)
82 static bool terminate; /* Are we terminating the program == cleaning up */
109 * Note that we go out of this function (the while loop below)
147 PC_DEBUG("%s: We let thread [%i] %i run\n", in posix_let_run()
156 * We let all threads know one is able to run now (it may even be us in posix_let_run()
158 * Note that as we hold the mutex, they are going to be blocked until in posix_let_run()
159 * we reach our own posix_wait_until_allowed() while loop in posix_let_run()
172 /* We detach ourselves so nobody needs to join to us */ in posix_preexit_cleanup()
203 * Note that we could have just done a swap(), but that would have left the
[all …]
|
| /Zephyr-Core-3.6.0/arch/riscv/core/ |
| D | fpu.c | 95 * then we know the in-memory copy is up to date and skip the FPU content
97 * we require that this be called only when the FPU is disabled.
141 /* search all CPUs for the owner we want */ in flush_owned_fpu()
149 /* we found it live on CPU i */ in flush_owned_fpu()
163 * we would be stuck here. in flush_owned_fpu()
166 * CPU, then we preemptively flush any live context in flush_owned_fpu()
167 * on this CPU as well since we're likely to in flush_owned_fpu()
196 * We also get here when FP regs are used while in exception as FP access
197 * is always disabled by default in that case. If so we save the FPU content
200 * there is nothing to save/restore for that context... as long as we
[all …]
|
| /Zephyr-Core-3.6.0/kernel/include/ |
| D | kswap.h | 24 * semantics. This means that whenever we are about to return to a
25 * thread (via either z_swap() or interrupt/exception return!) we need
41 * before arch_switch() finishes saving state. We must spin for the
62 * calling code to reorder before we saw switch_handle go in z_sched_switch_spin()
71 * Needed for SMP, where the scheduler requires spinlocking that we
86 * then we are context switching out of a nested lock in do_swap()
89 * during initialization (where we start with interrupts in do_swap()
111 /* We always take the scheduler spinlock if we don't already in do_swap()
112 * have it. We "release" other spinlocks here. But we never in do_swap()
150 /* Now add _current back to the run queue, once we are in do_swap()
[all …]
|
