diff options
| author | Frédéric Desbiens <[email protected]> | 2026-06-08 10:01:32 +0200 |
|---|---|---|
| committer | GitHub <[email protected]> | 2026-06-08 10:01:32 +0200 |
| commit | 87ab09cce305eb9cd4aacac4e8c62af72f665bff (patch) | |
| tree | dd062ebbea5235d1921c64b396bf7e4ce79e9e15 /ports_smp | |
| parent | 9ab0cf9683f832cdb48e2099533a5b06a3afcd64 (diff) | |
| parent | 730b61874bc5cf40768987605ae5187fde0fa1e2 (diff) | |
Merge pull request #544 from eclipse-threadx/devv6.5.1.202602_rel
Merging changes for the v.6.5.1.202602 release
Diffstat (limited to 'ports_smp')
118 files changed, 3670 insertions, 51 deletions
diff --git a/ports_smp/arc_hs_smp/metaware/example_build/sample_threadx/sample_threadx.c b/ports_smp/arc_hs_smp/metaware/example_build/sample_threadx/sample_threadx.c index 336ab326..0db5b9fa 100644 --- a/ports_smp/arc_hs_smp/metaware/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/arc_hs_smp/metaware/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/arc_hs_smp/metaware/example_build/sample_threadx/vectors.s b/ports_smp/arc_hs_smp/metaware/example_build/sample_threadx/vectors.s index 3ff8ae37..141c9867 100644 --- a/ports_smp/arc_hs_smp/metaware/example_build/sample_threadx/vectors.s +++ b/ports_smp/arc_hs_smp/metaware/example_build/sample_threadx/vectors.s @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + .file "vectors.s" .section .ivt,text diff --git a/ports_smp/arc_hs_smp/metaware/inc/tx_port.h b/ports_smp/arc_hs_smp/metaware/inc/tx_port.h index dd223a9c..ec99ea9f 100644 --- a/ports_smp/arc_hs_smp/metaware/inc/tx_port.h +++ b/ports_smp/arc_hs_smp/metaware/inc/tx_port.h @@ -395,7 +395,7 @@ typedef struct TX_THREAD_SMP_PROTECT_STRUCT #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/ARC_HS/MetaWare Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/ARC_HS/MetaWare Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a34_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a34_smp/ac6/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a34_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a34_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a34_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a34_smp/ac6/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a34_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a34_smp/ac6/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a34_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a34_smp/gnu/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a34_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a34_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a34_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a34_smp/gnu/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a34_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a34_smp/gnu/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a35_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a35_smp/ac6/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a35_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a35_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a35_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a35_smp/ac6/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a35_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a35_smp/ac6/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a35_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a35_smp/gnu/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a35_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a35_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a35_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a35_smp/gnu/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a35_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a35_smp/gnu/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a53_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a53_smp/ac6/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a53_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a53_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a53_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a53_smp/ac6/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a53_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a53_smp/ac6/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a53_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a53_smp/gnu/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a53_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a53_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a53_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a53_smp/gnu/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a53_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a53_smp/gnu/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a55_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a55_smp/ac6/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a55_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a55_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a55_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a55_smp/ac6/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a55_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a55_smp/ac6/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a55_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a55_smp/gnu/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a55_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a55_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a55_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a55_smp/gnu/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a55_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a55_smp/gnu/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a57_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a57_smp/ac6/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a57_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a57_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a57_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a57_smp/ac6/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a57_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a57_smp/ac6/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a57_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a57_smp/gnu/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a57_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a57_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a57_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a57_smp/gnu/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a57_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a57_smp/gnu/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a5_smp/ac5/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a5_smp/ac5/example_build/sample_threadx/sample_threadx.c index 5c1f4a16..81883601 100644 --- a/ports_smp/cortex_a5_smp/ac5/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a5_smp/ac5/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a5_smp/ac5/example_build/sample_threadx/v7.h b/ports_smp/cortex_a5_smp/ac5/example_build/sample_threadx/v7.h index c18b945c..4a500a59 100644 --- a/ports_smp/cortex_a5_smp/ac5/example_build/sample_threadx/v7.h +++ b/ports_smp/cortex_a5_smp/ac5/example_build/sample_threadx/v7.h @@ -35,7 +35,6 @@ void disableInterrupts(void); // ------------------------------------------------------------ // Caches -void invalidateCaches_IS(void); void cleanInvalidateDCache(void); void invalidateCaches_IS(void); void enableCaches(void); diff --git a/ports_smp/cortex_a5_smp/ac5/inc/tx_port.h b/ports_smp/cortex_a5_smp/ac5/inc/tx_port.h index e26d484b..89114f47 100644 --- a/ports_smp/cortex_a5_smp/ac5/inc/tx_port.h +++ b/ports_smp/cortex_a5_smp/ac5/inc/tx_port.h @@ -388,7 +388,7 @@ void tx_thread_vfp_disable(void); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/Cortex-A5/AC5 Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/Cortex-A5/AC5 Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a5_smp/gnu/example_build/sample_threadx.c b/ports_smp/cortex_a5_smp/gnu/example_build/sample_threadx.c index 5c1f4a16..81883601 100644 --- a/ports_smp/cortex_a5_smp/gnu/example_build/sample_threadx.c +++ b/ports_smp/cortex_a5_smp/gnu/example_build/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a5_smp/gnu/example_build/v7.h b/ports_smp/cortex_a5_smp/gnu/example_build/v7.h index c18b945c..4a500a59 100644 --- a/ports_smp/cortex_a5_smp/gnu/example_build/v7.h +++ b/ports_smp/cortex_a5_smp/gnu/example_build/v7.h @@ -35,7 +35,6 @@ void disableInterrupts(void); // ------------------------------------------------------------ // Caches -void invalidateCaches_IS(void); void cleanInvalidateDCache(void); void invalidateCaches_IS(void); void enableCaches(void); diff --git a/ports_smp/cortex_a5_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a5_smp/gnu/inc/tx_port.h index 324e2f54..59fa2062 100644 --- a/ports_smp/cortex_a5_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a5_smp/gnu/inc/tx_port.h @@ -391,7 +391,7 @@ void tx_thread_vfp_disable(void); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/Cortex-A5/GNU Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/Cortex-A5/GNU Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a5x_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a5x_smp/ac6/example_build/sample_threadx/sample_threadx.c index b766cf71..4bf11456 100644 --- a/ports_smp/cortex_a5x_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a5x_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a5x_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a5x_smp/ac6/inc/tx_port.h index 69cba68f..0c7b48f1 100644 --- a/ports_smp/cortex_a5x_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a5x_smp/ac6/inc/tx_port.h @@ -412,7 +412,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "Copyright (c) 1996-2019 Express Logic Inc. * ThreadX Cortex-A5x-SMP/AC6 Version 6.5.0.202601 *"; + "Copyright (c) 1996-2019 Express Logic Inc. * ThreadX Cortex-A5x-SMP/AC6 Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a5x_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a5x_smp/gnu/example_build/sample_threadx/sample_threadx.c index b766cf71..4bf11456 100644 --- a/ports_smp/cortex_a5x_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a5x_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a5x_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a5x_smp/gnu/inc/tx_port.h index 6048a955..00e916d7 100644 --- a/ports_smp/cortex_a5x_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a5x_smp/gnu/inc/tx_port.h @@ -412,7 +412,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX Cortex-A5x-SMP/GNU Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX Cortex-A5x-SMP/GNU Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a5x_smp/green/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a5x_smp/green/example_build/sample_threadx/sample_threadx.c index 67acbd1e..b0674a21 100644 --- a/ports_smp/cortex_a5x_smp/green/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a5x_smp/green/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a5x_smp/green/example_build/sample_threadx/stdio_ghs.c b/ports_smp/cortex_a5x_smp/green/example_build/sample_threadx/stdio_ghs.c index d780bd8f..976dde40 100644 --- a/ports_smp/cortex_a5x_smp/green/example_build/sample_threadx/stdio_ghs.c +++ b/ports_smp/cortex_a5x_smp/green/example_build/sample_threadx/stdio_ghs.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + #include <stdint.h> /* diff --git a/ports_smp/cortex_a5x_smp/green/inc/tx_port.h b/ports_smp/cortex_a5x_smp/green/inc/tx_port.h index 5776b126..aebb117e 100644 --- a/ports_smp/cortex_a5x_smp/green/inc/tx_port.h +++ b/ports_smp/cortex_a5x_smp/green/inc/tx_port.h @@ -432,7 +432,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX Cortex-A5x-SMP/GHS Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX Cortex-A5x-SMP/GHS Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a5x_smp/iar/inc/tx_port.h b/ports_smp/cortex_a5x_smp/iar/inc/tx_port.h index f46ceddf..86507d1d 100644 --- a/ports_smp/cortex_a5x_smp/iar/inc/tx_port.h +++ b/ports_smp/cortex_a5x_smp/iar/inc/tx_port.h @@ -441,7 +441,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX Cortex-A5x-SMP/IAR Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX Cortex-A5x-SMP/IAR Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a65_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a65_smp/ac6/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a65_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a65_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a65_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a65_smp/ac6/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a65_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a65_smp/ac6/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a65_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a65_smp/gnu/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a65_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a65_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a65_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a65_smp/gnu/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a65_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a65_smp/gnu/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a65ae_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a65ae_smp/ac6/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a65ae_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a65ae_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a65ae_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a65ae_smp/ac6/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a65ae_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a65ae_smp/ac6/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a65ae_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a65ae_smp/gnu/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a65ae_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a65ae_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a65ae_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a65ae_smp/gnu/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a65ae_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a65ae_smp/gnu/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a72_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a72_smp/ac6/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a72_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a72_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a72_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a72_smp/ac6/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a72_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a72_smp/ac6/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a72_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a72_smp/gnu/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a72_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a72_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a72_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a72_smp/gnu/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a72_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a72_smp/gnu/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a73_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a73_smp/ac6/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a73_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a73_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a73_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a73_smp/ac6/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a73_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a73_smp/ac6/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a73_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a73_smp/gnu/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a73_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a73_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a73_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a73_smp/gnu/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a73_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a73_smp/gnu/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a75_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a75_smp/ac6/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a75_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a75_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a75_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a75_smp/ac6/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a75_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a75_smp/ac6/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a75_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a75_smp/gnu/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a75_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a75_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a75_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a75_smp/gnu/inc/tx_port.h index 262f2ddf..07185eb6 100644 --- a/ports_smp/cortex_a75_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a75_smp/gnu/inc/tx_port.h @@ -187,7 +187,7 @@ typedef unsigned long long ALIGN_TYPE; /* Define various constants for the ThreadX ARM port. */ #define TX_INT_DISABLE 0xC0 /* Disable IRQ & FIQ interrupts */ -#define TX_INT_ENABLE 0x00 /* Enable IRQ & FIQ interrupts */ +#define TX_INT_ENABLE 0x00 /* Enable IRQ & FIQ interrupts */ /* Define the clock source for trace event entry time stamp. The following two item are port specific. @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a76_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a76_smp/ac6/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a76_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a76_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a76_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a76_smp/ac6/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a76_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a76_smp/ac6/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a76_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a76_smp/gnu/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a76_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a76_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a76_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a76_smp/gnu/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a76_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a76_smp/gnu/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a76ae_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a76ae_smp/ac6/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a76ae_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a76ae_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a76ae_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a76ae_smp/ac6/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a76ae_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a76ae_smp/ac6/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a76ae_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a76ae_smp/gnu/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a76ae_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a76ae_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a76ae_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a76ae_smp/gnu/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a76ae_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a76ae_smp/gnu/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a77_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a77_smp/ac6/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a77_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a77_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a77_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a77_smp/ac6/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a77_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a77_smp/ac6/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a77_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a77_smp/gnu/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a77_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a77_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a77_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a77_smp/gnu/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a77_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a77_smp/gnu/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a78_smp/ac6/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a78_smp/ac6/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a78_smp/ac6/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a78_smp/ac6/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a78_smp/ac6/inc/tx_port.h b/ports_smp/cortex_a78_smp/ac6/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a78_smp/ac6/inc/tx_port.h +++ b/ports_smp/cortex_a78_smp/ac6/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a78_smp/gnu/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a78_smp/gnu/example_build/sample_threadx/sample_threadx.c index 17cceb01..c9d1657e 100644 --- a/ports_smp/cortex_a78_smp/gnu/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a78_smp/gnu/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a78_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a78_smp/gnu/inc/tx_port.h index 262f2ddf..81f93d8b 100644 --- a/ports_smp/cortex_a78_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a78_smp/gnu/inc/tx_port.h @@ -411,7 +411,7 @@ VOID tx_thread_fp_disable(VOID); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv8-A-SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a7_smp/ac5/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a7_smp/ac5/example_build/sample_threadx/sample_threadx.c index 5c1f4a16..81883601 100644 --- a/ports_smp/cortex_a7_smp/ac5/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a7_smp/ac5/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a7_smp/ac5/example_build/sample_threadx/v7.h b/ports_smp/cortex_a7_smp/ac5/example_build/sample_threadx/v7.h index c18b945c..4a500a59 100644 --- a/ports_smp/cortex_a7_smp/ac5/example_build/sample_threadx/v7.h +++ b/ports_smp/cortex_a7_smp/ac5/example_build/sample_threadx/v7.h @@ -35,7 +35,6 @@ void disableInterrupts(void); // ------------------------------------------------------------ // Caches -void invalidateCaches_IS(void); void cleanInvalidateDCache(void); void invalidateCaches_IS(void); void enableCaches(void); diff --git a/ports_smp/cortex_a7_smp/ac5/inc/tx_port.h b/ports_smp/cortex_a7_smp/ac5/inc/tx_port.h index 69ac4b0f..ebdbddac 100644 --- a/ports_smp/cortex_a7_smp/ac5/inc/tx_port.h +++ b/ports_smp/cortex_a7_smp/ac5/inc/tx_port.h @@ -388,7 +388,7 @@ void tx_thread_vfp_disable(void); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/Cortex-A7/AC5 Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/Cortex-A7/AC5 Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a7_smp/gnu/example_build/sample_threadx.c b/ports_smp/cortex_a7_smp/gnu/example_build/sample_threadx.c index 5c1f4a16..81883601 100644 --- a/ports_smp/cortex_a7_smp/gnu/example_build/sample_threadx.c +++ b/ports_smp/cortex_a7_smp/gnu/example_build/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a7_smp/gnu/example_build/v7.h b/ports_smp/cortex_a7_smp/gnu/example_build/v7.h index 0fc0183f..88e88508 100644 --- a/ports_smp/cortex_a7_smp/gnu/example_build/v7.h +++ b/ports_smp/cortex_a7_smp/gnu/example_build/v7.h @@ -23,7 +23,6 @@ void disableInterrupts(void); // ------------------------------------------------------------ // Caches -void invalidateCaches_IS(void); void cleanInvalidateDCache(void); void invalidateCaches_IS(void); void enableCaches(void); diff --git a/ports_smp/cortex_a7_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a7_smp/gnu/inc/tx_port.h index db3f4093..7e266e07 100644 --- a/ports_smp/cortex_a7_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a7_smp/gnu/inc/tx_port.h @@ -386,7 +386,7 @@ void tx_thread_vfp_disable(void); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/Cortex-A7/GNU Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/Cortex-A7/GNU Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a9_smp/ac5/example_build/sample_threadx/sample_threadx.c b/ports_smp/cortex_a9_smp/ac5/example_build/sample_threadx/sample_threadx.c index 9daf05f6..e3e2a4a2 100644 --- a/ports_smp/cortex_a9_smp/ac5/example_build/sample_threadx/sample_threadx.c +++ b/ports_smp/cortex_a9_smp/ac5/example_build/sample_threadx/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a9_smp/ac5/example_build/sample_threadx/v7.s b/ports_smp/cortex_a9_smp/ac5/example_build/sample_threadx/v7.s index ab2f6feb..ff1ee1c9 100644 --- a/ports_smp/cortex_a9_smp/ac5/example_build/sample_threadx/v7.s +++ b/ports_smp/cortex_a9_smp/ac5/example_build/sample_threadx/v7.s @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + ; ------------------------------------------------------------ ; v7-A Cache and Branch Prediction Maintenance Operations ; ------------------------------------------------------------ diff --git a/ports_smp/cortex_a9_smp/ac5/inc/tx_port.h b/ports_smp/cortex_a9_smp/ac5/inc/tx_port.h index f065d5f2..4abe3aee 100644 --- a/ports_smp/cortex_a9_smp/ac5/inc/tx_port.h +++ b/ports_smp/cortex_a9_smp/ac5/inc/tx_port.h @@ -393,7 +393,7 @@ void tx_thread_vfp_disable(void); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/Cortex-A9/AC5 Version Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/Cortex-A9/AC5 Version Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_a9_smp/gnu/CMakeLists.txt b/ports_smp/cortex_a9_smp/gnu/CMakeLists.txt new file mode 100644 index 00000000..4b13e1a1 --- /dev/null +++ b/ports_smp/cortex_a9_smp/gnu/CMakeLists.txt @@ -0,0 +1,31 @@ +target_sources(${PROJECT_NAME} + PRIVATE + # {{BEGIN_TARGET_SOURCES}} + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_context_restore.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_context_save.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_interrupt_control.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_interrupt_disable.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_interrupt_restore.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_irq_nesting_end.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_irq_nesting_start.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_schedule.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_core_get.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_core_preempt.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_current_state_get.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_current_thread_get.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_initialize_wait.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_low_level_initialize.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_protect.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_time_get.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_unprotect.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_stack_build.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_system_return.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_vectored_context_save.S + ${CMAKE_CURRENT_LIST_DIR}/src/tx_timer_interrupt.S + # {{END_TARGET_SOURCES}} +) + +target_include_directories(${PROJECT_NAME} + PUBLIC + ${CMAKE_CURRENT_LIST_DIR}/inc +) diff --git a/ports_smp/cortex_a9_smp/gnu/example_build/build_threadx_sample.bat b/ports_smp/cortex_a9_smp/gnu/example_build/build_threadx_sample.bat index 22d0a618..07f887ed 100644 --- a/ports_smp/cortex_a9_smp/gnu/example_build/build_threadx_sample.bat +++ b/ports_smp/cortex_a9_smp/gnu/example_build/build_threadx_sample.bat @@ -1,8 +1,8 @@ -arm-none-eabi-gcc -c -g -I../../../../common_smp/inc -I../inc -mcpu=cortex-a5 sample_threadx.c +arm-none-eabi-gcc -c -g -I../../../../common_smp/inc -I../inc -mcpu=cortex-a9 sample_threadx.c arm-none-eabi-gcc -c -g -mcpu=cortex-a9 startup.S arm-none-eabi-gcc -c -g -mcpu=cortex-a9 MP_GIC.S arm-none-eabi-gcc -c -g -mcpu=cortex-a9 MP_SCU.S arm-none-eabi-gcc -c -g -mcpu=cortex-a9 MP_Mutexes.S arm-none-eabi-gcc -c -g -mcpu=cortex-a9 MP_PrivateTimer.S arm-none-eabi-gcc -c -g -mcpu=cortex-a9 v7.S -arm-none-eabi-gcc -T sample_threadx.ld -e Vectors -o sample_threadx.axf MP_PrivateTimer.o MP_GIC.o MP_Mutexes.o MP_SCU.o sample_threadx.o startup.o v7.o tx.a -Wl,-M > sample_threadx.map +arm-none-eabi-gcc -T sample_threadx.ld -e Vectors -mcpu=cortex-a9 --specs=nosys.specs -o sample_threadx.axf MP_PrivateTimer.o MP_GIC.o MP_Mutexes.o MP_SCU.o sample_threadx.o startup.o v7.o tx.a -Wl,-M > sample_threadx.map diff --git a/ports_smp/cortex_a9_smp/gnu/example_build/sample_threadx.c b/ports_smp/cortex_a9_smp/gnu/example_build/sample_threadx.c index 5c1f4a16..81883601 100644 --- a/ports_smp/cortex_a9_smp/gnu/example_build/sample_threadx.c +++ b/ports_smp/cortex_a9_smp/gnu/example_build/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_a9_smp/gnu/example_build/v7.h b/ports_smp/cortex_a9_smp/gnu/example_build/v7.h index c18b945c..4a500a59 100644 --- a/ports_smp/cortex_a9_smp/gnu/example_build/v7.h +++ b/ports_smp/cortex_a9_smp/gnu/example_build/v7.h @@ -35,7 +35,6 @@ void disableInterrupts(void); // ------------------------------------------------------------ // Caches -void invalidateCaches_IS(void); void cleanInvalidateDCache(void); void invalidateCaches_IS(void); void enableCaches(void); diff --git a/ports_smp/cortex_a9_smp/gnu/inc/tx_port.h b/ports_smp/cortex_a9_smp/gnu/inc/tx_port.h index a35403c7..d9cb3ace 100644 --- a/ports_smp/cortex_a9_smp/gnu/inc/tx_port.h +++ b/ports_smp/cortex_a9_smp/gnu/inc/tx_port.h @@ -386,7 +386,7 @@ void tx_thread_vfp_disable(void); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/Cortex-A9/GNU Version Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/Cortex-A9/GNU Version Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/cortex_r8_smp/ac5/example_build/sample_threadx/demo_threadx.c b/ports_smp/cortex_r8_smp/ac5/example_build/sample_threadx/demo_threadx.c index 57b2471e..69bbeedb 100644 --- a/ports_smp/cortex_r8_smp/ac5/example_build/sample_threadx/demo_threadx.c +++ b/ports_smp/cortex_r8_smp/ac5/example_build/sample_threadx/demo_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/cortex_r8_smp/ac5/example_build/sample_threadx/v7.S b/ports_smp/cortex_r8_smp/ac5/example_build/sample_threadx/v7.S index e732325c..87987e26 100644 --- a/ports_smp/cortex_r8_smp/ac5/example_build/sample_threadx/v7.S +++ b/ports_smp/cortex_r8_smp/ac5/example_build/sample_threadx/v7.S @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + ; ------------------------------------------------------------ ; v7 Cache and Branch Prediction Maintenance Operations ; ------------------------------------------------------------ diff --git a/ports_smp/cortex_r8_smp/ac5/inc/tx_port.h b/ports_smp/cortex_r8_smp/ac5/inc/tx_port.h index 842b16ae..432e3b70 100644 --- a/ports_smp/cortex_r8_smp/ac5/inc/tx_port.h +++ b/ports_smp/cortex_r8_smp/ac5/inc/tx_port.h @@ -393,7 +393,7 @@ void tx_thread_vfp_disable(void); #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv7-R SMP Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX ARMv7-R SMP Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/linux/gnu/example_build/sample_threadx.c b/ports_smp/linux/gnu/example_build/sample_threadx.c index 0947b428..e9bd167b 100644 --- a/ports_smp/linux/gnu/example_build/sample_threadx.c +++ b/ports_smp/linux/gnu/example_build/sample_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX SMP kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/linux/gnu/inc/tx_port.h b/ports_smp/linux/gnu/inc/tx_port.h index 30c94702..3e5e0128 100644 --- a/ports_smp/linux/gnu/inc/tx_port.h +++ b/ports_smp/linux/gnu/inc/tx_port.h @@ -622,7 +622,7 @@ void _tx_thread_smp_debug_entry_insert(ULONG id, ULONG su #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/Linux/gcc Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP/Linux/gcc Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/mips32_interaptiv_smp/gnu/example_build/demo_threadx.c b/ports_smp/mips32_interaptiv_smp/gnu/example_build/demo_threadx.c index c03bad2f..4f2a43b2 100644 --- a/ports_smp/mips32_interaptiv_smp/gnu/example_build/demo_threadx.c +++ b/ports_smp/mips32_interaptiv_smp/gnu/example_build/demo_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/mips32_interaptiv_smp/gnu/example_build/regdef.h b/ports_smp/mips32_interaptiv_smp/gnu/example_build/regdef.h index 01197f47..9fcf4c59 100644 --- a/ports_smp/mips32_interaptiv_smp/gnu/example_build/regdef.h +++ b/ports_smp/mips32_interaptiv_smp/gnu/example_build/regdef.h @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + #ifndef __REGDEF_H #define __REGDEF_H diff --git a/ports_smp/mips32_interaptiv_smp/gnu/inc/tx_port.h b/ports_smp/mips32_interaptiv_smp/gnu/inc/tx_port.h index a2429d57..edbf8fd5 100644 --- a/ports_smp/mips32_interaptiv_smp/gnu/inc/tx_port.h +++ b/ports_smp/mips32_interaptiv_smp/gnu/inc/tx_port.h @@ -419,7 +419,7 @@ THREAD_SMP_DECLARE ULONG _tx_thread_smp_initial_fpu_control_register; #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP MIPS32_interAptiv/GNU Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP MIPS32_interAptiv/GNU Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/mips32_interaptiv_smp/green/example_build/demo_threadx.c b/ports_smp/mips32_interaptiv_smp/green/example_build/demo_threadx.c index 8dcbcf10..47a535d2 100644 --- a/ports_smp/mips32_interaptiv_smp/green/example_build/demo_threadx.c +++ b/ports_smp/mips32_interaptiv_smp/green/example_build/demo_threadx.c @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + /* This is a small demo of the high-performance ThreadX kernel. It includes examples of eight threads of different priorities, using a message queue, semaphore, mutex, event flags group, byte pool, and block pool. */ diff --git a/ports_smp/mips32_interaptiv_smp/green/example_build/regdef.h b/ports_smp/mips32_interaptiv_smp/green/example_build/regdef.h index 01197f47..9fcf4c59 100644 --- a/ports_smp/mips32_interaptiv_smp/green/example_build/regdef.h +++ b/ports_smp/mips32_interaptiv_smp/green/example_build/regdef.h @@ -1,3 +1,14 @@ +/***************************************************************************/ +/* Copyright (c) 2024 Microsoft Corporation */ +/* Copyright (c) 2026 Eclipse ThreadX contributors */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the MIT License which is available at */ +/* https://opensource.org/licenses/MIT. */ +/* */ +/* SPDX-License-Identifier: MIT */ +/***************************************************************************/ + #ifndef __REGDEF_H #define __REGDEF_H diff --git a/ports_smp/mips32_interaptiv_smp/green/inc/tx_port.h b/ports_smp/mips32_interaptiv_smp/green/inc/tx_port.h index a4b88d1b..4eb4f3d6 100644 --- a/ports_smp/mips32_interaptiv_smp/green/inc/tx_port.h +++ b/ports_smp/mips32_interaptiv_smp/green/inc/tx_port.h @@ -509,7 +509,7 @@ THREAD_SMP_DECLARE ULONG _tx_thread_smp_initial_fpu_control_register; #ifdef TX_THREAD_INIT CHAR _tx_version_id[] = - "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP MIPS32_interAptiv/Green Hills Version 6.5.0.202601 *"; + "(c) 2024 Microsoft Corp. (c) 2026-present Eclipse ThreadX contributors. * ThreadX SMP MIPS32_interAptiv/Green Hills Version 6.5.1.202602 *"; #else extern CHAR _tx_version_id[]; #endif diff --git a/ports_smp/win64/vs_2022/CMakeLists.txt b/ports_smp/win64/vs_2022/CMakeLists.txt new file mode 100644 index 00000000..982f9684 --- /dev/null +++ b/ports_smp/win64/vs_2022/CMakeLists.txt @@ -0,0 +1,28 @@ +target_sources(${PROJECT_NAME} + PRIVATE + # {{BEGIN_TARGET_SOURCES}} + ${CMAKE_CURRENT_LIST_DIR}/src/tx_initialize_low_level.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_context_restore.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_context_save.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_interrupt_control.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_schedule.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_core_get.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_core_preempt.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_current_state_get.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_current_thread_get.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_initialize_wait.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_low_level_initialize.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_protect.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_time_get.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_smp_unprotect.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_stack_build.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_thread_system_return.c + ${CMAKE_CURRENT_LIST_DIR}/src/tx_timer_interrupt.c + + # {{END_TARGET_SOURCES}} +) + +target_include_directories(${PROJECT_NAME} + PUBLIC + ${CMAKE_CURRENT_LIST_DIR}/inc +) diff --git a/ports_smp/win64/vs_2022/inc/tx_port.h b/ports_smp/win64/vs_2022/inc/tx_port.h new file mode 100644 index 00000000..d9790f35 --- /dev/null +++ b/ports_smp/win64/vs_2022/inc/tx_port.h @@ -0,0 +1,532 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +#ifndef TX_PORT_H +#define TX_PORT_H + +/************* Define ThreadX SMP constants. *************/ + +#define TX_DISABLE_INLINE + +#ifndef TX_THREAD_SMP_MAX_CORES +#define TX_THREAD_SMP_MAX_CORES 4 +#endif + +#ifndef TX_THREAD_SMP_CORE_MASK +#define TX_THREAD_SMP_CORE_MASK 0xFU +#endif + +#define TX_PORT_SPECIFIC_PRE_INITIALIZATION +#define TX_THREAD_SMP_INTER_CORE_INTERRUPT +#define TX_THREAD_SMP_DEFAULT_WAKEUP_LOGIC + +#ifdef TX_THREAD_SMP_WAKEUP_LOGIC +#include "tx_thread_smp_core_wakeup.h" +#else +#ifdef TX_THREAD_SMP_DEFAULT_WAKEUP_LOGIC +#define TX_THREAD_SMP_WAKEUP_LOGIC +#define TX_THREAD_SMP_WAKEUP(i) _tx_thread_smp_core_preempt(i) +#endif +#endif + +#ifdef TX_INLINE_THREAD_RESUME_SUSPEND +#undef TX_INLINE_THREAD_RESUME_SUSPEND +#endif + +#define INLINE_DECLARE __inline + +/************* End ThreadX SMP constants. *************/ + + +#ifdef TX_INCLUDE_USER_DEFINE_FILE +#include "tx_user.h" +#endif + + +#define VOID void +typedef char CHAR; +typedef unsigned char UCHAR; +typedef int INT; +typedef unsigned int UINT; +typedef long LONG; +typedef unsigned long ULONG; +typedef short SHORT; +typedef unsigned short USHORT; +typedef unsigned long long ULONG64; +#define ULONG64_DEFINED + +#define ALIGN_TYPE_DEFINED +typedef unsigned long long ALIGN_TYPE; + +#define TX_BYTE_BLOCK_FREE ((ALIGN_TYPE) 0xFFFFEEEEFFFFEEEEULL) + + +#include <stdint.h> +#include <stdlib.h> +#include <string.h> + +#ifndef __GNUC__ +#ifndef __attribute__ +#define __attribute__(a) +#endif +#endif + +typedef unsigned int TEST_FLAG; +extern TEST_FLAG threadx_byte_allocate_loop_test; +extern TEST_FLAG threadx_byte_release_loop_test; +extern TEST_FLAG threadx_mutex_suspension_put_test; +extern TEST_FLAG threadx_mutex_suspension_priority_test; +#ifndef TX_TIMER_PROCESS_IN_ISR +extern TEST_FLAG threadx_delete_timer_thread; +#endif +extern void abort_and_resume_byte_allocating_thread(void); +extern void abort_all_threads_suspended_on_mutex(void); +extern void suspend_lowest_priority(void); +#ifndef TX_TIMER_PROCESS_IN_ISR +extern void delete_timer_thread(void); +#endif +extern TEST_FLAG test_stack_analyze_flag; +extern TEST_FLAG test_initialize_flag; +extern TEST_FLAG test_forced_mutex_timeout; +extern UINT mutex_priority_change_extension_selection; +extern UINT priority_change_extension_selection; + +#ifdef TX_REGRESSION_TEST + +#define TX_PORT_SPECIFIC_MEMORY_SYNCHRONIZATION other_core_status = other_core_status + _tx_thread_system_state[0]; \ + _tx_thread_system_state[0] = 0; + +#define TX_BYTE_ALLOCATE_EXTENSION if (threadx_byte_allocate_loop_test == ((TEST_FLAG) 1)) \ + { \ + pool_ptr -> tx_byte_pool_owner = TX_NULL; \ + threadx_byte_allocate_loop_test = ((TEST_FLAG) 0); \ + } + +#define TX_BYTE_RELEASE_EXTENSION if (threadx_byte_release_loop_test == ((TEST_FLAG) 1)) \ + { \ + threadx_byte_release_loop_test = ((TEST_FLAG) 0); \ + abort_and_resume_byte_allocating_thread(); \ + } + +#define TX_MUTEX_PUT_EXTENSION_1 if (threadx_mutex_suspension_put_test == ((TEST_FLAG) 1)) \ + { \ + threadx_mutex_suspension_put_test = ((TEST_FLAG) 0); \ + abort_all_threads_suspended_on_mutex(); \ + } + +#define TX_MUTEX_PUT_EXTENSION_2 if (test_forced_mutex_timeout == ((TEST_FLAG) 1)) \ + { \ + test_forced_mutex_timeout = ((TEST_FLAG) 0); \ + _tx_thread_wait_abort(mutex_ptr -> tx_mutex_suspension_list); \ + } + +#define TX_MUTEX_PRIORITY_CHANGE_EXTENSION if (threadx_mutex_suspension_priority_test == ((TEST_FLAG) 1)) \ + { \ + threadx_mutex_suspension_priority_test = ((TEST_FLAG) 0); \ + if (mutex_priority_change_extension_selection == 2U) \ + original_priority = new_priority; \ + if (mutex_priority_change_extension_selection == 3U) \ + original_pt_thread = thread_ptr; \ + if (mutex_priority_change_extension_selection == 4U) \ + { \ + execute_ptr = thread_ptr; \ + _tx_thread_preemption__threshold_scheduled = TX_NULL; \ + } \ + suspend_lowest_priority(); \ + } + +#define TX_THREAD_PRIORITY_CHANGE_EXTENSION if (priority_change_extension_selection != ((TEST_FLAG) 0)) \ + { \ + if (priority_change_extension_selection == 1U) \ + thread_ptr -> tx_thread_smp_core_mapped = TX_THREAD_SMP_MAX_CORES; \ + else if (priority_change_extension_selection == 2U) \ + { \ + original_priority = new_priority; \ + _tx_thread_execute_ptr[0] = TX_NULL; \ + } \ + else if (priority_change_extension_selection == 3U) \ + { \ + original_pt_thread = thread_ptr; \ + } \ + else \ + { \ + _tx_thread_preemption__threshold_scheduled = TX_NULL; \ + } \ + priority_change_extension_selection = 0; \ + } + +#ifndef TX_TIMER_PROCESS_IN_ISR +#define TX_TIMER_INITIALIZE_EXTENSION(a) if (threadx_delete_timer_thread == ((TEST_FLAG) 1)) \ + { \ + threadx_delete_timer_thread = ((TEST_FLAG) 0); \ + delete_timer_thread(); \ + (a) = ((UINT) 1); \ + } +#endif + +#define TX_THREAD_STACK_ANALYZE_EXTENSION if (test_stack_analyze_flag == ((TEST_FLAG) 1)) \ + { \ + thread_ptr -> tx_thread_id = ((TEST_FLAG) 0); \ + test_stack_analyze_flag = ((TEST_FLAG) 0); \ + } \ + else if (test_stack_analyze_flag == ((TEST_FLAG) 2)) \ + { \ + stack_ptr = thread_ptr -> tx_thread_stack_start; \ + test_stack_analyze_flag = ((TEST_FLAG) 0); \ + } \ + else if (test_stack_analyze_flag == ((TEST_FLAG) 3)) \ + { \ + *stack_ptr = TX_STACK_FILL; \ + test_stack_analyze_flag = ((TEST_FLAG) 0); \ + } \ + else \ + { \ + test_stack_analyze_flag = ((TEST_FLAG) 0); \ + } + +#define TX_INITIALIZE_KERNEL_ENTER_EXTENSION if (test_initialize_flag == ((TEST_FLAG) 1)) \ + { \ + test_initialize_flag = ((TEST_FLAG) 0); \ + return; \ + } + +#endif + + +void _tx_win32_debug_entry_insert(char *action, char *file, unsigned long line); + +#ifndef TX_WIN32_DEBUG_ENABLE +#define _tx_win32_debug_entry_insert(a, b, c) +#endif + + +#ifndef TX_MISRA_ENABLE +#define TX_MEMSET(a,b,c) { \ + UCHAR *ptr; \ + UCHAR value; \ + UINT i, size; \ + ptr = (UCHAR *) ((VOID *) a); \ + value = (UCHAR) b; \ + size = (UINT) c; \ + for (i = 0; i < size; i++) \ + { \ + *ptr++ = value; \ + } \ + } +#endif + + +#include <windows.h> + +#ifndef TX_WIN32_USE_ADDRESS_WAIT +#define TX_WIN32_USE_ADDRESS_WAIT 1 +#endif + +#ifndef TX_WIN32_USE_HIGH_RESOLUTION_TIMER +#define TX_WIN32_USE_HIGH_RESOLUTION_TIMER 1 +#endif + +#ifndef CREATE_WAITABLE_TIMER_HIGH_RESOLUTION +#define CREATE_WAITABLE_TIMER_HIGH_RESOLUTION 0x00000002UL +#endif + + +#ifndef TX_MAX_PRIORITIES +#define TX_MAX_PRIORITIES 32 +#endif + +#ifndef TX_MINIMUM_STACK +#define TX_MINIMUM_STACK 200 +#endif + +#ifndef TX_TIMER_THREAD_STACK_SIZE +#define TX_TIMER_THREAD_STACK_SIZE 400 +#endif + +#ifndef TX_TIMER_THREAD_PRIORITY +#define TX_TIMER_THREAD_PRIORITY 0 +#endif + +#define TX_INT_DISABLE 1 +#define TX_INT_ENABLE 0 + +#ifndef TX_TRACE_TIME_SOURCE +#define TX_TRACE_TIME_SOURCE ((ULONG) (_tx_win32_time_stamp.LowPart)) +#endif + +#ifndef TX_TRACE_TIME_MASK +#define TX_TRACE_TIME_MASK 0xFFFFFFFFUL +#endif + +#define TX_TRACE_PORT_EXTENSION QueryPerformanceCounter((LARGE_INTEGER *)&_tx_win32_time_stamp); +#define TX_PORT_SPECIFIC_BUILD_OPTIONS 0 + +#ifdef TX_MISRA_ENABLE +#define TX_DISABLE_INLINE +#else +#define TX_INLINE_INITIALIZATION +#endif + +void _tx_initialize_start_interrupts(void); + +#define TX_PORT_SPECIFIC_PRE_SCHEDULER_INITIALIZATION _tx_initialize_start_interrupts(); \ + { \ + UINT k; \ + for (k = 1U; k < TX_THREAD_SMP_MAX_CORES; k++) \ + { \ + _tx_thread_system_state[k] = 0; \ + } \ + } + +#ifdef TX_WIN32_PROFILE_ENABLE +#define TX_WIN32_PROFILE_THREAD_EXTENSION ULONG64 tx_thread_win32_profile_run_signal_ticks; \ + ULONG64 tx_thread_win32_profile_run_wake_ticks; +#else +#define TX_WIN32_PROFILE_THREAD_EXTENSION +#endif + +#ifndef TX_MISRA_ENABLE +#ifdef TX_ENABLE_STACK_CHECKING +#undef TX_DISABLE_STACK_FILLING +#endif +#endif + + +#define TX_THREAD_EXTENSION_0 HANDLE tx_thread_win32_thread_handle; \ + DWORD tx_thread_win32_thread_id; \ + HANDLE tx_thread_win32_thread_run_semaphore; \ + HANDLE tx_thread_win32_thread_start_semaphore; \ + LONG tx_thread_win32_run_sequence; \ + LONG tx_thread_win32_run_sequence_seen; \ + LONG tx_thread_win32_start_sequence; \ + UINT tx_thread_win32_suspension_type; \ + UINT tx_thread_win32_mutex_access; \ + UINT tx_thread_win32_int_disabled_flag; \ + UINT tx_thread_win32_deferred_preempt; \ + UINT tx_thread_win32_virtual_core; \ + TX_WIN32_PROFILE_THREAD_EXTENSION +#define TX_THREAD_EXTENSION_1 +#define TX_THREAD_EXTENSION_2 +#define TX_THREAD_EXTENSION_3 + +#define TX_BLOCK_POOL_EXTENSION +#define TX_BYTE_POOL_EXTENSION +#define TX_EVENT_FLAGS_GROUP_EXTENSION +#define TX_MUTEX_EXTENSION +#define TX_QUEUE_EXTENSION +#define TX_SEMAPHORE_EXTENSION +#define TX_TIMER_EXTENSION + +#ifndef TX_THREAD_USER_EXTENSION +#define TX_THREAD_USER_EXTENSION +#endif + +#define TX_THREAD_CREATE_EXTENSION(thread_ptr) +#define TX_THREAD_DELETE_EXTENSION(thread_ptr) +#define TX_THREAD_COMPLETED_EXTENSION(thread_ptr) +#define TX_THREAD_TERMINATED_EXTENSION(thread_ptr) + +#define TX_BLOCK_POOL_CREATE_EXTENSION(pool_ptr) +#define TX_BYTE_POOL_CREATE_EXTENSION(pool_ptr) +#define TX_EVENT_FLAGS_GROUP_CREATE_EXTENSION(group_ptr) +#define TX_MUTEX_CREATE_EXTENSION(mutex_ptr) +#define TX_QUEUE_CREATE_EXTENSION(queue_ptr) +#define TX_SEMAPHORE_CREATE_EXTENSION(semaphore_ptr) +#define TX_TIMER_CREATE_EXTENSION(timer_ptr) + + +#define TX_TIMER_INTERNAL_EXTENSION VOID *tx_timer_internal_extension_ptr; + +#define TX_THREAD_CREATE_TIMEOUT_SETUP(t) (t) -> tx_thread_timer.tx_timer_internal_timeout_function = &(_tx_thread_timeout); \ + (t) -> tx_thread_timer.tx_timer_internal_timeout_param = 0; \ + (t) -> tx_thread_timer.tx_timer_internal_extension_ptr = (VOID *) (t); + +#define TX_THREAD_TIMEOUT_POINTER_SETUP(t) (t) = (TX_THREAD *) _tx_timer_expired_timer_ptr -> tx_timer_internal_extension_ptr; + + +struct TX_THREAD_STRUCT; + +typedef struct TX_WIN32_CRITICAL_SECTION_STRUCT +{ + HANDLE tx_win32_critical_section_mutex_handle; + DWORD tx_win32_critical_section_owner; + ULONG tx_win32_critical_section_nested_count; +} TX_WIN32_CRITICAL_SECTION; + +void _tx_win32_critical_section_obtain(TX_WIN32_CRITICAL_SECTION *critical_section); +void _tx_win32_critical_section_release(TX_WIN32_CRITICAL_SECTION *critical_section); +void _tx_win32_critical_section_release_all(TX_WIN32_CRITICAL_SECTION *critical_section); + +typedef struct TX_THREAD_STRUCT TX_THREAD; + +void _tx_thread_delete_port_completion(TX_THREAD *thread_ptr, UINT tx_interrupt_save); +#define TX_THREAD_DELETE_PORT_COMPLETION(thread_ptr) _tx_thread_delete_port_completion(thread_ptr, tx_interrupt_save); + +void _tx_thread_reset_port_completion(TX_THREAD *thread_ptr, UINT tx_interrupt_save); +#define TX_THREAD_RESET_PORT_COMPLETION(thread_ptr) _tx_thread_reset_port_completion(thread_ptr, tx_interrupt_save); + + +typedef struct TX_THREAD_SMP_PROTECT_STRUCT +{ + ULONG tx_thread_smp_protect_in_force; + struct TX_THREAD_STRUCT *tx_thread_smp_protect_thread; + ULONG tx_thread_smp_protect_core; + ULONG tx_thread_smp_protect_count; + DWORD tx_thread_smp_protect_thread_id; +} TX_THREAD_SMP_PROTECT; + +typedef struct TX_THREAD_SMP_CORE_MAPPING_STRUCT +{ + HANDLE tx_thread_smp_core_mapping_thread_handle; + DWORD tx_thread_smp_core_mapping_thread_id; + struct TX_THREAD_STRUCT *tx_thread_smp_core_mapping_thread; +} TX_THREAD_SMP_CORE_MAPPING; + +struct TX_THREAD_STRUCT * _tx_thread_smp_current_thread_get(void); +UINT _tx_thread_smp_core_get(void); +void _tx_thread_smp_core_preempt(UINT core); +UINT _tx_thread_smp_protect(void); +void _tx_thread_smp_unprotect(UINT interrupt_save); +ULONG _tx_thread_smp_current_state_get(void); +ULONG _tx_thread_smp_time_get(void); +void _tx_thread_smp_low_level_initialize(UINT number_of_cores); +void _tx_thread_smp_initialize_wait(void); + +#ifdef TX_THREAD_SMP_DEBUG_ENABLE +void _tx_thread_smp_debug_entry_insert(ULONG id, ULONG suspend, VOID *thread_ptr); +#else +#define _tx_thread_smp_debug_entry_insert(a, b, c) +#endif + +#define TX_SMP_CORE_ID _tx_thread_smp_core_get() + + +#define TX_BLOCK_POOL_DELETE_EXTENSION(pool_ptr) +#define TX_BYTE_POOL_DELETE_EXTENSION(pool_ptr) +#define TX_EVENT_FLAGS_GROUP_DELETE_EXTENSION(group_ptr) +#define TX_MUTEX_DELETE_EXTENSION(mutex_ptr) +#define TX_QUEUE_DELETE_EXTENSION(queue_ptr) +#define TX_SEMAPHORE_DELETE_EXTENSION(semaphore_ptr) +#define TX_TIMER_DELETE_EXTENSION(timer_ptr) + + +UINT _tx_thread_interrupt_disable(void); +VOID _tx_thread_interrupt_restore(UINT previous_posture); +UINT _tx_thread_interrupt_control(UINT new_posture); + +#define TX_INTERRUPT_SAVE_AREA UINT tx_interrupt_save; +#define TX_DISABLE tx_interrupt_save = _tx_thread_smp_protect(); +#define TX_RESTORE _tx_thread_smp_unprotect(tx_interrupt_save); + + +#define TX_BLOCK_POOL_DISABLE TX_DISABLE +#define TX_BYTE_POOL_DISABLE TX_DISABLE +#define TX_EVENT_FLAGS_GROUP_DISABLE TX_DISABLE +#define TX_MUTEX_DISABLE TX_DISABLE +#define TX_QUEUE_DISABLE TX_DISABLE +#define TX_SEMAPHORE_DISABLE TX_DISABLE + + +#ifdef TX_THREAD_INIT +CHAR _tx_version_id[] = + "(c) 2026 Eclipse ThreadX contributors. * ThreadX SMP/Win64/MSVC Version 6.5.1.202602 *"; +#else +extern CHAR _tx_version_id[]; +#endif + + +extern TX_WIN32_CRITICAL_SECTION _tx_win32_critical_section; +extern HANDLE _tx_win32_scheduler_event; +extern DWORD _tx_win32_scheduler_id; +extern ULONG _tx_win32_global_int_disabled_flag; +extern LARGE_INTEGER _tx_win32_time_stamp; +extern ULONG _tx_win32_system_error; +extern HANDLE _tx_win32_timer_handle; +extern HANDLE _tx_win32_timer_thread_handle; +extern DWORD _tx_win32_timer_thread_id; +extern HANDLE _tx_win32_isr_semaphore; +extern UINT _tx_win32_timer_waiting; +extern TX_THREAD_SMP_CORE_MAPPING _tx_win32_virtual_cores[TX_THREAD_SMP_MAX_CORES]; +extern __declspec(thread) int _tx_win32_threadx_thread; +extern __declspec(thread) UINT _tx_win32_current_virtual_core; + +UINT _tx_win32_smp_current_core_get(void); +void _tx_win32_thread_suspend(HANDLE thread_handle); +void _tx_win32_thread_resume(HANDLE thread_handle); +void _tx_win32_thread_sleep(ULONG milliseconds); +void _tx_win32_thread_yield(void); +void _tx_win32_semaphore_reset(HANDLE semaphore_handle); +LONG _tx_win32_thread_start_sequence_get(TX_THREAD *thread_ptr); +void _tx_win32_thread_run_signal(TX_THREAD *thread_ptr); +DWORD _tx_win32_wait_for_thread_run(TX_THREAD *thread_ptr); +void _tx_win32_thread_start_ack_signal(TX_THREAD *thread_ptr); +DWORD _tx_win32_wait_for_scheduler_event(void); +DWORD _tx_win32_wait_for_thread_run_semaphore(HANDLE semaphore_handle); +DWORD _tx_win32_wait_for_thread_start_semaphore(HANDLE semaphore_handle); +DWORD _tx_win32_wait_for_thread_start_ack(TX_THREAD *thread_ptr, LONG start_sequence); +DWORD _tx_win32_wait_for_isr_semaphore(void); +DWORD _tx_win32_wait_for_isr_rendezvous(void); +DWORD _tx_win32_wait_for_timer_object(void); +#ifdef TX_WIN32_PROFILE_ENABLE +void _tx_win32_profile_reset(void); +void _tx_win32_profile_report(CHAR *label); +void _tx_win32_profile_mark_run_signal(TX_THREAD *thread_ptr); +void _tx_win32_profile_mark_run_wake(TX_THREAD *thread_ptr); +void _tx_win32_profile_mark_start_ack(TX_THREAD *thread_ptr); +#endif + +#ifndef TX_WIN32_MEMORY_SIZE +#define TX_WIN32_MEMORY_SIZE 100000 +#endif + +#ifndef TX_TIMER_TICKS_PER_SECOND +#define TX_TIMER_TICKS_PER_SECOND 100UL +#endif + +#ifndef TX_WIN32_THREAD_STACK_SIZE +#define TX_WIN32_THREAD_STACK_SIZE 65536 +#endif + +#ifndef TX_TIMER_PERIODIC +#ifdef TX_WIN32_SLOW_TIMER +#define TX_TIMER_PERIODIC TX_WIN32_SLOW_TIMER +#else +#define TX_TIMER_PERIODIC 10 +#endif +#endif + +#ifndef TX_WIN32_ISR_PERIODIC +#if defined(CTEST) || defined(BATCH_TEST) +#define TX_WIN32_ISR_PERIODIC 1 +#else +#define TX_WIN32_ISR_PERIODIC TX_TIMER_PERIODIC +#endif +#endif + +#if (TX_WIN32_ISR_PERIODIC > TX_TIMER_PERIODIC) +#error "TX_WIN32_ISR_PERIODIC must not exceed TX_TIMER_PERIODIC" +#endif + +#if ((TX_TIMER_PERIODIC % TX_WIN32_ISR_PERIODIC) != 0) +#error "TX_TIMER_PERIODIC must be an integer multiple of TX_WIN32_ISR_PERIODIC" +#endif + +#define TX_WIN32_TIMER_INTERRUPTS_PER_TICK (TX_TIMER_PERIODIC / TX_WIN32_ISR_PERIODIC) + +#define TX_WIN32_PRIORITY_SCHEDULE THREAD_PRIORITY_NORMAL +#define TX_WIN32_PRIORITY_ISR THREAD_PRIORITY_HIGHEST +#define TX_WIN32_PRIORITY_USER_THREAD THREAD_PRIORITY_LOWEST + +#endif diff --git a/ports_smp/win64/vs_2022/readme_threadx.txt b/ports_smp/win64/vs_2022/readme_threadx.txt new file mode 100644 index 00000000..f37fc056 --- /dev/null +++ b/ports_smp/win64/vs_2022/readme_threadx.txt @@ -0,0 +1,13 @@ +This port provides a Windows-hosted SMP simulation environment for ThreadX. + +The implementation models virtual ThreadX cores on top of Win64 host threads. +It is intended for validation and regression testing only. It is not a +production runtime port for deploying ThreadX applications on Windows. + +Key characteristics: +- ThreadX cores are virtual scheduler-owned mappings, not Windows CPU numbers. +- One Windows host thread is created for each ThreadX thread. +- A dedicated scheduler thread and a dedicated timer/ISR thread coordinate the + simulation. +- SuspendThread and ResumeThread are used only to emulate asynchronous + preemption in the simulator. diff --git a/ports_smp/win64/vs_2022/src/tx_initialize_low_level.c b/ports_smp/win64/vs_2022/src/tx_initialize_low_level.c new file mode 100644 index 00000000..f517fd6b --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_initialize_low_level.c @@ -0,0 +1,1150 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +// Some portions generated by Codex (gpt 5.5). +// Some portions generated by GitHub Copilot (claude-sonnet-4.6). + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" +#include "tx_timer.h" + +#include <mmsystem.h> +#include <stdio.h> + +#pragma comment (lib, "Winmm.lib") +#if (TX_WIN32_USE_ADDRESS_WAIT != 0) +#pragma comment (lib, "Synchronization.lib") +#endif + +TX_WIN32_CRITICAL_SECTION _tx_win32_critical_section; +HANDLE _tx_win32_scheduler_event; +DWORD _tx_win32_scheduler_id; +ULONG _tx_win32_global_int_disabled_flag; +LARGE_INTEGER _tx_win32_time_stamp; +ULONG _tx_win32_system_error; +HANDLE _tx_win32_timer_handle; +HANDLE _tx_win32_timer_thread_handle; +DWORD _tx_win32_timer_thread_id; +HANDLE _tx_win32_isr_semaphore; +UINT _tx_win32_timer_waiting; +TX_THREAD_SMP_CORE_MAPPING _tx_win32_virtual_cores[TX_THREAD_SMP_MAX_CORES]; +__declspec(thread) int _tx_win32_threadx_thread = 0; +__declspec(thread) UINT _tx_win32_current_virtual_core = 0U; + +static VOID _tx_win32_timer_start(VOID); +static DWORD WINAPI _tx_win32_timer_thread_entry(LPVOID thread_input); +static UINT _tx_win32_smp_current_core_get_internal(DWORD thread_id); +static UINT _tx_win32_smp_thread_core_get(DWORD thread_id); + +#ifndef TX_WIN32_CONTENTION_PAUSE_COUNT +#define TX_WIN32_CONTENTION_PAUSE_COUNT 256U +#endif + +#ifdef TX_WIN32_PROFILE_ENABLE +typedef struct TX_WIN32_PROFILE_STRUCT +{ + ULONG64 tx_win32_profile_start_ticks; + ULONG64 tx_win32_profile_scheduler_wait_ticks; + ULONG64 tx_win32_profile_thread_run_wait_ticks; + ULONG64 tx_win32_profile_thread_start_wait_ticks; + ULONG64 tx_win32_profile_thread_start_ack_wait_ticks; + ULONG64 tx_win32_profile_run_signal_to_wake_ticks; + ULONG64 tx_win32_profile_run_wake_to_ack_ticks; + ULONG64 tx_win32_profile_isr_wait_ticks; + ULONG64 tx_win32_profile_isr_rendezvous_wait_ticks; + ULONG64 tx_win32_profile_timer_wait_ticks; + ULONG64 tx_win32_profile_suspend_ticks; + ULONG64 tx_win32_profile_resume_ticks; + ULONG64 tx_win32_profile_semaphore_reset_ticks; + ULONG64 tx_win32_profile_critical_section_spin_ticks; + ULONG64 tx_win32_profile_yield_ticks; + ULONG tx_win32_profile_scheduler_wait_count; + ULONG tx_win32_profile_thread_run_wait_count; + ULONG tx_win32_profile_thread_start_wait_count; + ULONG tx_win32_profile_thread_start_ack_wait_count; + ULONG tx_win32_profile_run_signal_to_wake_count; + ULONG tx_win32_profile_run_wake_to_ack_count; + ULONG tx_win32_profile_isr_wait_count; + ULONG tx_win32_profile_isr_rendezvous_wait_count; + ULONG tx_win32_profile_timer_wait_count; + ULONG tx_win32_profile_suspend_count; + ULONG tx_win32_profile_resume_count; + ULONG tx_win32_profile_semaphore_reset_count; + ULONG tx_win32_profile_semaphore_reset_loops; + ULONG tx_win32_profile_critical_section_spin_count; + ULONG tx_win32_profile_yield_count; +} TX_WIN32_PROFILE; + +static TX_WIN32_PROFILE _tx_win32_profile; +static LARGE_INTEGER _tx_win32_profile_frequency; + +static ULONG64 _tx_win32_profile_time_get(VOID); +static VOID _tx_win32_profile_accumulate(ULONG64 *ticks_total, ULONG *count_total, ULONG64 start_ticks); +static double _tx_win32_profile_ticks_to_ms(ULONG64 ticks); +#endif + +#ifdef TX_WIN32_DEBUG_ENABLE + +#ifndef TX_WIN32_DEBUG_EVENT_SIZE +#define TX_WIN32_DEBUG_EVENT_SIZE 400 +#endif + +typedef struct TX_WIN32_DEBUG_ENTRY_STRUCT +{ + char *tx_win32_debug_entry_action; + DWORD tx_win32_debug_entry_running_id; + UINT tx_win32_debug_entry_core; + LARGE_INTEGER tx_win32_debug_entry_timestamp; + char *tx_win32_debug_entry_file; + unsigned long tx_win32_debug_entry_line; + TX_WIN32_CRITICAL_SECTION tx_win32_debug_entry_critical_section; + TX_THREAD_SMP_PROTECT tx_win32_debug_protection; + unsigned long tx_win32_debug_entry_int_disabled_flag; + UINT tx_win32_debug_entry_preempt_disable; + ULONG tx_win32_debug_entry_system_state[TX_THREAD_SMP_MAX_CORES]; + TX_THREAD *tx_win32_debug_entry_current_thread[TX_THREAD_SMP_MAX_CORES]; + DWORD tx_win32_debug_entry_current_thread_id[TX_THREAD_SMP_MAX_CORES]; + TX_THREAD *tx_win32_debug_entry_execute_thread[TX_THREAD_SMP_MAX_CORES]; + DWORD tx_win32_debug_entry_execute_thread_id[TX_THREAD_SMP_MAX_CORES]; +} TX_WIN32_DEBUG_ENTRY; + +TX_WIN32_DEBUG_ENTRY _tx_win32_debug_entry_array[TX_WIN32_DEBUG_EVENT_SIZE]; +unsigned long _tx_win32_debug_entry_index = 0; + +void _tx_win32_debug_entry_insert(char *action, char *file, unsigned long line) +{ +UINT i; +DWORD thread_id; + + QueryPerformanceCounter((LARGE_INTEGER *) &_tx_win32_time_stamp); + thread_id = GetCurrentThreadId(); + + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_action = action; + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_core = _tx_win32_smp_current_core_get_internal(thread_id); + if (_tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_core == TX_THREAD_SMP_MAX_CORES) + { + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_core = 0U; + } + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_timestamp = _tx_win32_time_stamp; + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_file = file; + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_line = line; + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_protection = _tx_thread_smp_protection; + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_preempt_disable = _tx_thread_preempt_disable; + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_critical_section = _tx_win32_critical_section; + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_int_disabled_flag = _tx_win32_global_int_disabled_flag; + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_running_id = thread_id; + + for (i = 0U; i < TX_THREAD_SMP_MAX_CORES; i++) + { + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_system_state[i] = _tx_thread_system_state[i]; + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_current_thread[i] = _tx_thread_current_ptr[i]; + if (_tx_thread_current_ptr[i] != TX_NULL) + { + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_current_thread_id[i] = + _tx_thread_current_ptr[i] -> tx_thread_win32_thread_id; + } + else + { + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_current_thread_id[i] = 0U; + } + + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_execute_thread[i] = _tx_thread_execute_ptr[i]; + if (_tx_thread_execute_ptr[i] != TX_NULL) + { + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_execute_thread_id[i] = + _tx_thread_execute_ptr[i] -> tx_thread_win32_thread_id; + } + else + { + _tx_win32_debug_entry_array[_tx_win32_debug_entry_index].tx_win32_debug_entry_execute_thread_id[i] = 0U; + } + } + + _tx_win32_debug_entry_index++; + if (_tx_win32_debug_entry_index >= TX_WIN32_DEBUG_EVENT_SIZE) + { + _tx_win32_debug_entry_index = 0U; + } +} + +#endif + + +void _tx_timer_interrupt(void); +VOID _tx_thread_context_save(VOID); +VOID _tx_thread_context_restore(VOID); +VOID _tx_win32_timer_interrupt(VOID); +#if defined(CTEST) || defined(BATCH_TEST) +VOID test_interrupt_dispatch(VOID); +extern VOID (*test_isr_dispatch)(void); +#if (TX_WIN32_ISR_PERIODIC < TX_TIMER_PERIODIC) +static VOID _tx_win32_timer_tick_process(VOID); +static UINT _tx_win32_timer_fast_active; +static UINT _tx_win32_timer_fast_count; +#endif +#endif + + +VOID _tx_initialize_low_level(VOID) +{ +UINT i; +TIMECAPS tc; +UINT timer_resolution; + + _tx_initialize_unused_memory = malloc(TX_WIN32_MEMORY_SIZE); + _tx_win32_scheduler_id = GetCurrentThreadId(); + + _tx_win32_critical_section.tx_win32_critical_section_mutex_handle = CreateMutex(NULL, FALSE, NULL); + _tx_win32_critical_section.tx_win32_critical_section_nested_count = 0U; + _tx_win32_critical_section.tx_win32_critical_section_owner = 0U; + if (_tx_win32_critical_section.tx_win32_critical_section_mutex_handle == NULL) + { + printf("ThreadX SMP Win64 error creating critical section mutex!\n"); + while (1) + { + } + } + + _tx_win32_scheduler_event = CreateEvent(NULL, FALSE, FALSE, NULL); + _tx_win32_isr_semaphore = CreateSemaphore(NULL, 0, 0x7FFFFFFF, NULL); + if ((_tx_win32_scheduler_event == NULL) || + (_tx_win32_isr_semaphore == NULL)) + { + printf("ThreadX SMP Win64 error creating semaphores!\n"); + while (1) + { + } + } + + for (i = 0U; i < TX_THREAD_SMP_MAX_CORES; i++) + { + _tx_win32_virtual_cores[i].tx_thread_smp_core_mapping_thread_handle = NULL; + _tx_win32_virtual_cores[i].tx_thread_smp_core_mapping_thread_id = 0U; + _tx_win32_virtual_cores[i].tx_thread_smp_core_mapping_thread = TX_NULL; + } + + _tx_win32_global_int_disabled_flag = TX_FALSE; + _tx_win32_timer_waiting = 0U; +#if (defined(CTEST) || defined(BATCH_TEST)) && (TX_WIN32_ISR_PERIODIC < TX_TIMER_PERIODIC) + _tx_win32_timer_fast_active = TX_FALSE; + _tx_win32_timer_fast_count = 0U; +#endif + +#ifdef TX_WIN32_PROFILE_ENABLE + if (_tx_win32_profile_frequency.QuadPart == 0) + { + QueryPerformanceFrequency(&_tx_win32_profile_frequency); + } + _tx_win32_profile_reset(); +#endif + + if (timeGetDevCaps(&tc, sizeof(TIMECAPS)) != TIMERR_NOERROR) + { + printf("ThreadX SMP Win64 error querying timer resolution!\n"); + while (1) + { + } + } + + timer_resolution = (UINT) min(max(tc.wPeriodMin, TX_WIN32_ISR_PERIODIC), tc.wPeriodMax); + if (timeBeginPeriod(timer_resolution) != TIMERR_NOERROR) + { + printf("ThreadX SMP Win64 error configuring timer resolution!\n"); + while (1) + { + } + } + +#if (TX_WIN32_USE_HIGH_RESOLUTION_TIMER != 0) + _tx_win32_timer_handle = CreateWaitableTimerEx(NULL, NULL, CREATE_WAITABLE_TIMER_HIGH_RESOLUTION, TIMER_ALL_ACCESS); + if (_tx_win32_timer_handle == NULL) +#endif + { + _tx_win32_timer_handle = CreateWaitableTimer(NULL, FALSE, NULL); + } + + if (_tx_win32_timer_handle == NULL) + { + printf("ThreadX SMP Win64 error creating timer handle!\n"); + while (1) + { + } + } + + _tx_win32_timer_thread_handle = CreateThread(NULL, 0, _tx_win32_timer_thread_entry, NULL, 0, &_tx_win32_timer_thread_id); + if (_tx_win32_timer_thread_handle == NULL) + { + printf("ThreadX SMP Win64 error creating timer thread!\n"); + while (1) + { + } + } + + SetThreadPriority(GetCurrentThread(), TX_WIN32_PRIORITY_SCHEDULE); + SetThreadPriority(_tx_win32_timer_thread_handle, TX_WIN32_PRIORITY_ISR); +} + +#ifdef TX_WIN32_PROFILE_ENABLE +static ULONG64 _tx_win32_profile_time_get(VOID) +{ +LARGE_INTEGER current_time; + + QueryPerformanceCounter(¤t_time); + return((ULONG64) current_time.QuadPart); +} + + +static VOID _tx_win32_profile_accumulate(ULONG64 *ticks_total, ULONG *count_total, ULONG64 start_ticks) +{ +ULONG64 end_ticks; + + end_ticks = _tx_win32_profile_time_get(); + *ticks_total = *ticks_total + (end_ticks - start_ticks); + *count_total = *count_total + 1UL; +} + + +static double _tx_win32_profile_ticks_to_ms(ULONG64 ticks) +{ +double frequency; + + frequency = (double) _tx_win32_profile_frequency.QuadPart; + if (frequency == 0.0) + { + return(0.0); + } + + return((((double) ticks) * 1000.0) / frequency); +} + + +void _tx_win32_profile_reset(VOID) +{ + TX_MEMSET(&_tx_win32_profile, 0, sizeof(TX_WIN32_PROFILE)); + _tx_win32_profile.tx_win32_profile_start_ticks = _tx_win32_profile_time_get(); +} + + +void _tx_win32_profile_report(CHAR *label) +{ +ULONG64 elapsed_ticks; + + elapsed_ticks = _tx_win32_profile_time_get() - _tx_win32_profile.tx_win32_profile_start_ticks; + + printf("**** Win64 SMP Profile (%s) elapsed_ms=%.3f\n", + label, + _tx_win32_profile_ticks_to_ms(elapsed_ticks)); + printf("**** waits: scheduler=%lu/%.3fms run=%lu/%.3fms start=%lu/%.3fms start_ack=%lu/%.3fms sig_wake=%lu/%.3fms wake_ack=%lu/%.3fms isr=%lu/%.3fms isr_rdv=%lu/%.3fms timer=%lu/%.3fms\n", + _tx_win32_profile.tx_win32_profile_scheduler_wait_count, + _tx_win32_profile_ticks_to_ms(_tx_win32_profile.tx_win32_profile_scheduler_wait_ticks), + _tx_win32_profile.tx_win32_profile_thread_run_wait_count, + _tx_win32_profile_ticks_to_ms(_tx_win32_profile.tx_win32_profile_thread_run_wait_ticks), + _tx_win32_profile.tx_win32_profile_thread_start_wait_count, + _tx_win32_profile_ticks_to_ms(_tx_win32_profile.tx_win32_profile_thread_start_wait_ticks), + _tx_win32_profile.tx_win32_profile_thread_start_ack_wait_count, + _tx_win32_profile_ticks_to_ms(_tx_win32_profile.tx_win32_profile_thread_start_ack_wait_ticks), + _tx_win32_profile.tx_win32_profile_run_signal_to_wake_count, + _tx_win32_profile_ticks_to_ms(_tx_win32_profile.tx_win32_profile_run_signal_to_wake_ticks), + _tx_win32_profile.tx_win32_profile_run_wake_to_ack_count, + _tx_win32_profile_ticks_to_ms(_tx_win32_profile.tx_win32_profile_run_wake_to_ack_ticks), + _tx_win32_profile.tx_win32_profile_isr_wait_count, + _tx_win32_profile_ticks_to_ms(_tx_win32_profile.tx_win32_profile_isr_wait_ticks), + _tx_win32_profile.tx_win32_profile_isr_rendezvous_wait_count, + _tx_win32_profile_ticks_to_ms(_tx_win32_profile.tx_win32_profile_isr_rendezvous_wait_ticks), + _tx_win32_profile.tx_win32_profile_timer_wait_count, + _tx_win32_profile_ticks_to_ms(_tx_win32_profile.tx_win32_profile_timer_wait_ticks)); + printf("**** host ops: suspend=%lu/%.3fms resume=%lu/%.3fms reset=%lu/%.3fms reset_loops=%lu cs_spin=%lu/%.3fms yield=%lu/%.3fms\n", + _tx_win32_profile.tx_win32_profile_suspend_count, + _tx_win32_profile_ticks_to_ms(_tx_win32_profile.tx_win32_profile_suspend_ticks), + _tx_win32_profile.tx_win32_profile_resume_count, + _tx_win32_profile_ticks_to_ms(_tx_win32_profile.tx_win32_profile_resume_ticks), + _tx_win32_profile.tx_win32_profile_semaphore_reset_count, + _tx_win32_profile_ticks_to_ms(_tx_win32_profile.tx_win32_profile_semaphore_reset_ticks), + _tx_win32_profile.tx_win32_profile_semaphore_reset_loops, + _tx_win32_profile.tx_win32_profile_critical_section_spin_count, + _tx_win32_profile_ticks_to_ms(_tx_win32_profile.tx_win32_profile_critical_section_spin_ticks), + _tx_win32_profile.tx_win32_profile_yield_count, + _tx_win32_profile_ticks_to_ms(_tx_win32_profile.tx_win32_profile_yield_ticks)); +} + + +void _tx_win32_profile_mark_run_signal(TX_THREAD *thread_ptr) +{ + thread_ptr -> tx_thread_win32_profile_run_signal_ticks = _tx_win32_profile_time_get(); + thread_ptr -> tx_thread_win32_profile_run_wake_ticks = 0ULL; +} + + +void _tx_win32_profile_mark_run_wake(TX_THREAD *thread_ptr) +{ +ULONG64 current_ticks; +ULONG64 signal_ticks; + + current_ticks = _tx_win32_profile_time_get(); + signal_ticks = thread_ptr -> tx_thread_win32_profile_run_signal_ticks; + + if (signal_ticks != 0ULL) + { + _tx_win32_profile.tx_win32_profile_run_signal_to_wake_ticks = + _tx_win32_profile.tx_win32_profile_run_signal_to_wake_ticks + (current_ticks - signal_ticks); + _tx_win32_profile.tx_win32_profile_run_signal_to_wake_count++; + } + + thread_ptr -> tx_thread_win32_profile_run_signal_ticks = 0ULL; + thread_ptr -> tx_thread_win32_profile_run_wake_ticks = current_ticks; +} + + +void _tx_win32_profile_mark_start_ack(TX_THREAD *thread_ptr) +{ +ULONG64 current_ticks; +ULONG64 wake_ticks; + + current_ticks = _tx_win32_profile_time_get(); + wake_ticks = thread_ptr -> tx_thread_win32_profile_run_wake_ticks; + + if (wake_ticks != 0ULL) + { + _tx_win32_profile.tx_win32_profile_run_wake_to_ack_ticks = + _tx_win32_profile.tx_win32_profile_run_wake_to_ack_ticks + (current_ticks - wake_ticks); + _tx_win32_profile.tx_win32_profile_run_wake_to_ack_count++; + } + + thread_ptr -> tx_thread_win32_profile_run_wake_ticks = 0ULL; +} +#endif + + +void _tx_initialize_start_interrupts(void) +{ + _tx_win32_timer_start(); +} + + +void _tx_win32_critical_section_obtain(TX_WIN32_CRITICAL_SECTION *critical_section) +{ +DWORD thread_id; +LONG previous_owner; +UINT contention_count; +TX_THREAD *current_thread; +UINT core_scan; +#ifdef TX_WIN32_PROFILE_ENABLE +ULONG64 start_ticks; +#endif + + thread_id = GetCurrentThreadId(); + + if (critical_section -> tx_win32_critical_section_owner == thread_id) + { + critical_section -> tx_win32_critical_section_nested_count++; + } + else + { + /* If this is a ThreadX application thread, signal that it is about to + * spin waiting for the critical section. context_save checks this flag + * before calling SuspendThread(): a thread that is merely blocked on the + * spinlock does not need to be OS-suspended — it cannot execute protected + * code anyway, and will proceed automatically once the CS is released. + * The flag is cleared below once the CS has been acquired. + * + * Identify the calling thread by scanning _tx_win32_virtual_cores for a + * matching OS thread ID. As a fast path, check the TLS-cached virtual core + * index first; fall back to a full scan only when the TLS value is stale + * (e.g., after a type-1 scheduler hand-off moves the thread to a new core). + * Worst case: the entry is momentarily absent and current_thread stays + * TX_NULL, which simply skips the mutex_access optimisation this cycle. */ + current_thread = TX_NULL; + if (_tx_win32_threadx_thread != 0) + { + core_scan = _tx_win32_current_virtual_core; + if ((core_scan < TX_THREAD_SMP_MAX_CORES) && + (_tx_win32_virtual_cores[core_scan].tx_thread_smp_core_mapping_thread_id == thread_id)) + { + current_thread = _tx_win32_virtual_cores[core_scan].tx_thread_smp_core_mapping_thread; + } + else + { + for (core_scan = 0U; core_scan < TX_THREAD_SMP_MAX_CORES; core_scan++) + { + if (_tx_win32_virtual_cores[core_scan].tx_thread_smp_core_mapping_thread_id == thread_id) + { + current_thread = _tx_win32_virtual_cores[core_scan].tx_thread_smp_core_mapping_thread; + break; + } + } + } + if (current_thread != TX_NULL) + { + current_thread -> tx_thread_win32_mutex_access = TX_TRUE; + } + } + + contention_count = 0U; +#ifdef TX_WIN32_PROFILE_ENABLE + start_ticks = _tx_win32_profile_time_get(); +#endif + do + { + previous_owner = InterlockedCompareExchange((LONG *) &(critical_section -> tx_win32_critical_section_owner), (LONG) thread_id, 0L); + + if (previous_owner != 0L) + { +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile.tx_win32_profile_critical_section_spin_count++; +#endif + contention_count++; + if (contention_count < TX_WIN32_CONTENTION_PAUSE_COUNT) + { + YieldProcessor(); + } + else + { + contention_count = 0U; + _tx_win32_thread_yield(); + } + } + } while (previous_owner != 0L); + +#ifdef TX_WIN32_PROFILE_ENABLE + if (critical_section -> tx_win32_critical_section_owner == thread_id) + { + _tx_win32_profile.tx_win32_profile_critical_section_spin_ticks = + _tx_win32_profile.tx_win32_profile_critical_section_spin_ticks + + (_tx_win32_profile_time_get() - start_ticks); + } +#endif + /* CS acquired; clear the spinning flag so the next timer ISR will see + * the thread as normally running. The thread is now inside the CS body + * and the ISR cannot reach context_save until we release the CS. */ + if (current_thread != TX_NULL) + { + current_thread -> tx_thread_win32_mutex_access = TX_FALSE; + } + + critical_section -> tx_win32_critical_section_nested_count = 1U; + } +} + + +void _tx_win32_critical_section_release(TX_WIN32_CRITICAL_SECTION *critical_section) +{ +DWORD thread_id; + + thread_id = GetCurrentThreadId(); + + if (critical_section -> tx_win32_critical_section_owner == thread_id) + { + if (critical_section -> tx_win32_critical_section_nested_count != 0U) + { + critical_section -> tx_win32_critical_section_nested_count--; + + if (critical_section -> tx_win32_critical_section_nested_count == 0U) + { + InterlockedExchange((LONG *) &(critical_section -> tx_win32_critical_section_owner), 0L); + } + } + } + else + { + _tx_win32_system_error++; + } +} + + +void _tx_win32_critical_section_release_all(TX_WIN32_CRITICAL_SECTION *critical_section) +{ +DWORD thread_id; + + thread_id = GetCurrentThreadId(); + + if (critical_section -> tx_win32_critical_section_owner == thread_id) + { + if (critical_section -> tx_win32_critical_section_nested_count != 0U) + { + critical_section -> tx_win32_critical_section_nested_count = 0U; + InterlockedExchange((LONG *) &(critical_section -> tx_win32_critical_section_owner), 0L); + } + } + else + { + _tx_win32_system_error++; + } +} + + +UINT _tx_win32_smp_current_core_get(void) +{ +UINT core; +DWORD thread_id; +UINT critical_section_owned; + + thread_id = GetCurrentThreadId(); + critical_section_owned = (UINT) (_tx_win32_critical_section.tx_win32_critical_section_owner == thread_id); + + if (critical_section_owned == TX_FALSE) + { + _tx_win32_critical_section_obtain(&_tx_win32_critical_section); + } + + if (_tx_win32_threadx_thread != 0) + { + core = _tx_win32_smp_thread_core_get(thread_id); + + if (core == TX_THREAD_SMP_MAX_CORES) + { + core = _tx_win32_current_virtual_core; + } + else + { + _tx_win32_current_virtual_core = core; + } + } + else + { + core = _tx_win32_smp_current_core_get_internal(thread_id); + if (core == TX_THREAD_SMP_MAX_CORES) + { + core = 0U; + } + } + + if (critical_section_owned == TX_FALSE) + { + _tx_win32_critical_section_release(&_tx_win32_critical_section); + } + + return(core); +} + + +static UINT _tx_win32_smp_thread_core_get(DWORD thread_id) +{ +UINT core; +UINT i; +TX_THREAD *thread_ptr; + + core = TX_THREAD_SMP_MAX_CORES; + + for (i = 0U; i < TX_THREAD_SMP_MAX_CORES; i++) + { + if (_tx_win32_virtual_cores[i].tx_thread_smp_core_mapping_thread_id == thread_id) + { + core = i; + break; + } + } + + if (core == TX_THREAD_SMP_MAX_CORES) + { + for (i = 0U; i < TX_THREAD_SMP_MAX_CORES; i++) + { + thread_ptr = _tx_thread_current_ptr[i]; + if ((thread_ptr != TX_NULL) && (thread_ptr -> tx_thread_win32_thread_id == thread_id)) + { + core = i; + break; + } + } + } + + return(core); +} + + +static UINT _tx_win32_smp_current_core_get_internal(DWORD thread_id) +{ +UINT core; +UINT i; +TX_THREAD *thread_ptr; + + core = _tx_win32_smp_thread_core_get(thread_id); + + if (core == TX_THREAD_SMP_MAX_CORES) + { + for (i = 0U; i < TX_THREAD_SMP_MAX_CORES; i++) + { + thread_ptr = _tx_thread_execute_ptr[i]; + if ((thread_ptr != TX_NULL) && (thread_ptr -> tx_thread_win32_thread_id == thread_id)) + { + core = i; + break; + } + } + } + + return(core); +} + + +void _tx_win32_thread_suspend(HANDLE thread_handle) +{ +#ifdef TX_WIN32_PROFILE_ENABLE +ULONG64 start_ticks; + + start_ticks = _tx_win32_profile_time_get(); +#endif + if (SuspendThread(thread_handle) == (DWORD) -1) + { + _tx_win32_system_error++; + while (1) + { + } + } +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_accumulate(&_tx_win32_profile.tx_win32_profile_suspend_ticks, + &_tx_win32_profile.tx_win32_profile_suspend_count, + start_ticks); +#endif +} + + +void _tx_win32_thread_resume(HANDLE thread_handle) +{ + DWORD suspend_count; +#ifdef TX_WIN32_PROFILE_ENABLE +ULONG64 start_ticks; + + start_ticks = _tx_win32_profile_time_get(); +#endif + + do + { + suspend_count = ResumeThread(thread_handle); + if (suspend_count == (DWORD) -1) + { + _tx_win32_system_error++; + while (1) + { + } + } + } while (suspend_count > 1U); +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_accumulate(&_tx_win32_profile.tx_win32_profile_resume_ticks, + &_tx_win32_profile.tx_win32_profile_resume_count, + start_ticks); +#endif +} + + +void _tx_win32_thread_sleep(ULONG milliseconds) +{ + if (milliseconds == 0U) + { + milliseconds = 1U; + } + + Sleep((DWORD) milliseconds); +} + + +void _tx_win32_thread_yield(VOID) +{ +#ifdef TX_WIN32_PROFILE_ENABLE +ULONG64 start_ticks; + + start_ticks = _tx_win32_profile_time_get(); +#endif + + if (SwitchToThread() == 0) + { + Sleep(0); + } + +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_accumulate(&_tx_win32_profile.tx_win32_profile_yield_ticks, + &_tx_win32_profile.tx_win32_profile_yield_count, + start_ticks); +#endif +} + + +void _tx_win32_semaphore_reset(HANDLE semaphore_handle) +{ +#ifdef TX_WIN32_PROFILE_ENABLE +ULONG64 start_ticks; + + start_ticks = _tx_win32_profile_time_get(); +#endif + + while (WaitForSingleObject(semaphore_handle, 0) == WAIT_OBJECT_0) + { +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile.tx_win32_profile_semaphore_reset_loops++; +#endif + } + +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_accumulate(&_tx_win32_profile.tx_win32_profile_semaphore_reset_ticks, + &_tx_win32_profile.tx_win32_profile_semaphore_reset_count, + start_ticks); +#endif +} + + +LONG _tx_win32_thread_start_sequence_get(TX_THREAD *thread_ptr) +{ +#if (TX_WIN32_USE_ADDRESS_WAIT != 0) + return(thread_ptr -> tx_thread_win32_start_sequence); +#else + TX_PARAMETER_NOT_USED(thread_ptr); + return(0L); +#endif +} + + +void _tx_win32_thread_run_signal(TX_THREAD *thread_ptr) +{ +#if (TX_WIN32_USE_ADDRESS_WAIT != 0) + (void) InterlockedIncrement(&(thread_ptr -> tx_thread_win32_run_sequence)); + WakeByAddressSingle(&(thread_ptr -> tx_thread_win32_run_sequence)); +#else + ReleaseSemaphore(thread_ptr -> tx_thread_win32_thread_run_semaphore, 1, NULL); +#endif +} + + +DWORD _tx_win32_wait_for_thread_run(TX_THREAD *thread_ptr) +{ +DWORD wait_status; +#if (TX_WIN32_USE_ADDRESS_WAIT != 0) +LONG observed_sequence; +LONG current_sequence; +#endif +#ifdef TX_WIN32_PROFILE_ENABLE +ULONG64 start_ticks; + + start_ticks = _tx_win32_profile_time_get(); +#endif + +#if (TX_WIN32_USE_ADDRESS_WAIT != 0) + wait_status = WAIT_OBJECT_0; + observed_sequence = thread_ptr -> tx_thread_win32_run_sequence_seen; + current_sequence = thread_ptr -> tx_thread_win32_run_sequence; + + while (current_sequence == observed_sequence) + { + if (WaitOnAddress(&(thread_ptr -> tx_thread_win32_run_sequence), + &observed_sequence, + sizeof(thread_ptr -> tx_thread_win32_run_sequence), + INFINITE) == 0) + { + _tx_win32_system_error++; + wait_status = WAIT_FAILED; + break; + } + + current_sequence = thread_ptr -> tx_thread_win32_run_sequence; + } + + if (wait_status == WAIT_OBJECT_0) + { + thread_ptr -> tx_thread_win32_run_sequence_seen = current_sequence; + } +#else + wait_status = WaitForSingleObject(thread_ptr -> tx_thread_win32_thread_run_semaphore, INFINITE); +#endif + +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_accumulate(&_tx_win32_profile.tx_win32_profile_thread_run_wait_ticks, + &_tx_win32_profile.tx_win32_profile_thread_run_wait_count, + start_ticks); +#endif + + return(wait_status); +} + + +void _tx_win32_thread_start_ack_signal(TX_THREAD *thread_ptr) +{ +#if (TX_WIN32_USE_ADDRESS_WAIT != 0) + (void) InterlockedIncrement(&(thread_ptr -> tx_thread_win32_start_sequence)); + WakeByAddressSingle(&(thread_ptr -> tx_thread_win32_start_sequence)); +#else + ReleaseSemaphore(thread_ptr -> tx_thread_win32_thread_start_semaphore, 1, NULL); +#endif +} + + +DWORD _tx_win32_wait_for_scheduler_event(VOID) +{ +DWORD wait_status; +#ifdef TX_WIN32_PROFILE_ENABLE +ULONG64 start_ticks; + + start_ticks = _tx_win32_profile_time_get(); +#endif + + /* Use a 2 ms timeout (matching the Linux SMP port's sem_timedwait interval) so that + * a missed SetEvent() does not stall the scheduler indefinitely and so that the + * timer-tick phase varies slightly between iterations, preventing a systematic + * resonance where the ISR always fires outside the _tx_thread_preempt_disable + * window (which would make tests like threadx_thread_wait_abort_and_isr_test + * take an unreasonably long time to complete). */ + wait_status = WaitForSingleObject(_tx_win32_scheduler_event, 2U); + +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_accumulate(&_tx_win32_profile.tx_win32_profile_scheduler_wait_ticks, + &_tx_win32_profile.tx_win32_profile_scheduler_wait_count, + start_ticks); +#endif + + return(wait_status); +} + + +DWORD _tx_win32_wait_for_thread_run_semaphore(HANDLE semaphore_handle) +{ +DWORD wait_status; +#ifdef TX_WIN32_PROFILE_ENABLE +ULONG64 start_ticks; + + start_ticks = _tx_win32_profile_time_get(); +#endif + + wait_status = WaitForSingleObject(semaphore_handle, INFINITE); + +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_accumulate(&_tx_win32_profile.tx_win32_profile_thread_run_wait_ticks, + &_tx_win32_profile.tx_win32_profile_thread_run_wait_count, + start_ticks); +#endif + + return(wait_status); +} + + +DWORD _tx_win32_wait_for_thread_start_semaphore(HANDLE semaphore_handle) +{ +DWORD wait_status; +#ifdef TX_WIN32_PROFILE_ENABLE +ULONG64 start_ticks; + + start_ticks = _tx_win32_profile_time_get(); +#endif + + wait_status = WaitForSingleObject(semaphore_handle, INFINITE); + +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_accumulate(&_tx_win32_profile.tx_win32_profile_thread_start_wait_ticks, + &_tx_win32_profile.tx_win32_profile_thread_start_wait_count, + start_ticks); +#endif + + return(wait_status); +} + + +DWORD _tx_win32_wait_for_thread_start_ack(TX_THREAD *thread_ptr, LONG start_sequence) +{ +DWORD wait_status; +#if (TX_WIN32_USE_ADDRESS_WAIT != 0) +LONG current_sequence; +#endif +#ifdef TX_WIN32_PROFILE_ENABLE +ULONG64 start_ticks; + + start_ticks = _tx_win32_profile_time_get(); +#endif + +#if (TX_WIN32_USE_ADDRESS_WAIT != 0) + wait_status = WAIT_OBJECT_0; + current_sequence = thread_ptr -> tx_thread_win32_start_sequence; + + while (current_sequence == start_sequence) + { + if (WaitOnAddress(&(thread_ptr -> tx_thread_win32_start_sequence), + &start_sequence, + sizeof(thread_ptr -> tx_thread_win32_start_sequence), + INFINITE) == 0) + { + _tx_win32_system_error++; + wait_status = WAIT_FAILED; + break; + } + + current_sequence = thread_ptr -> tx_thread_win32_start_sequence; + } +#else + TX_PARAMETER_NOT_USED(start_sequence); + wait_status = WaitForSingleObject(thread_ptr -> tx_thread_win32_thread_start_semaphore, INFINITE); +#endif + +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_accumulate(&_tx_win32_profile.tx_win32_profile_thread_start_ack_wait_ticks, + &_tx_win32_profile.tx_win32_profile_thread_start_ack_wait_count, + start_ticks); +#endif + + return(wait_status); +} + + +DWORD _tx_win32_wait_for_isr_semaphore(VOID) +{ +DWORD wait_status; +#ifdef TX_WIN32_PROFILE_ENABLE +ULONG64 start_ticks; + + start_ticks = _tx_win32_profile_time_get(); +#endif + + wait_status = WaitForSingleObject(_tx_win32_isr_semaphore, INFINITE); + +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_accumulate(&_tx_win32_profile.tx_win32_profile_isr_wait_ticks, + &_tx_win32_profile.tx_win32_profile_isr_wait_count, + start_ticks); +#endif + + return(wait_status); +} + + +DWORD _tx_win32_wait_for_isr_rendezvous(VOID) +{ +DWORD wait_status; +#ifdef TX_WIN32_PROFILE_ENABLE +ULONG64 start_ticks; + + start_ticks = _tx_win32_profile_time_get(); +#endif + + wait_status = WaitForSingleObject(_tx_win32_isr_semaphore, INFINITE); + +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_accumulate(&_tx_win32_profile.tx_win32_profile_isr_rendezvous_wait_ticks, + &_tx_win32_profile.tx_win32_profile_isr_rendezvous_wait_count, + start_ticks); +#endif + + return(wait_status); +} + + +DWORD _tx_win32_wait_for_timer_object(VOID) +{ +DWORD wait_status; +#ifdef TX_WIN32_PROFILE_ENABLE +ULONG64 start_ticks; + + start_ticks = _tx_win32_profile_time_get(); +#endif + + wait_status = WaitForSingleObject(_tx_win32_timer_handle, INFINITE); + +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_accumulate(&_tx_win32_profile.tx_win32_profile_timer_wait_ticks, + &_tx_win32_profile.tx_win32_profile_timer_wait_count, + start_ticks); +#endif + + return(wait_status); +} + + +static DWORD WINAPI _tx_win32_timer_thread_entry(LPVOID thread_input) +{ + TX_PARAMETER_NOT_USED(thread_input); + + while (1) + { + _tx_win32_wait_for_timer_object(); + _tx_win32_timer_interrupt(); + _tx_win32_timer_start(); + } +} + + +VOID _tx_win32_timer_interrupt(VOID) +{ + _tx_thread_context_save(); +#if defined(CTEST) || defined(BATCH_TEST) + test_interrupt_dispatch(); +#if (TX_WIN32_ISR_PERIODIC < TX_TIMER_PERIODIC) + _tx_win32_timer_tick_process(); +#else + _tx_timer_interrupt(); +#endif +#else + _tx_timer_interrupt(); +#endif + _tx_thread_context_restore(); +} + + +#if (defined(CTEST) || defined(BATCH_TEST)) && (TX_WIN32_ISR_PERIODIC < TX_TIMER_PERIODIC) +static VOID _tx_win32_timer_tick_process(VOID) +{ + if (test_isr_dispatch != TX_NULL) + { + if (_tx_win32_timer_fast_active == TX_FALSE) + { + _tx_win32_timer_fast_active = TX_TRUE; + _tx_win32_timer_fast_count = 0U; + } + else + { + _tx_win32_timer_fast_count++; + if (_tx_win32_timer_fast_count < TX_WIN32_TIMER_INTERRUPTS_PER_TICK) + { + return; + } + + _tx_win32_timer_fast_count = 0U; + } + } + else + { + _tx_win32_timer_fast_active = TX_FALSE; + _tx_win32_timer_fast_count = 0U; + } + + _tx_timer_interrupt(); +} +#endif + + +static VOID _tx_win32_timer_start(VOID) +{ +LARGE_INTEGER due_time; +LONGLONG timer_period; + +#if (defined(CTEST) || defined(BATCH_TEST)) && (TX_WIN32_ISR_PERIODIC < TX_TIMER_PERIODIC) + if (test_isr_dispatch != TX_NULL) + { + timer_period = (LONGLONG) TX_WIN32_ISR_PERIODIC; + } + else +#endif + { + timer_period = (LONGLONG) TX_TIMER_PERIODIC; + } + + due_time.QuadPart = -(timer_period * 10000LL); +#if (TX_WIN32_USE_HIGH_RESOLUTION_TIMER != 0) + if (SetWaitableTimerEx(_tx_win32_timer_handle, &due_time, 0, NULL, NULL, NULL, 0) == 0) +#else + if (SetWaitableTimer(_tx_win32_timer_handle, &due_time, 0, NULL, NULL, FALSE) == 0) +#endif + { + printf("ThreadX SMP Win64 error starting timer!\n"); + while (1) + { + } + } +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_context_restore.c b/ports_smp/win64/vs_2022/src/tx_thread_context_restore.c new file mode 100644 index 00000000..d1b74c38 --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_context_restore.c @@ -0,0 +1,139 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +// Some portions generated by Codex (gpt 5.5). +// Some portions generated by GitHub Copilot (claude-sonnet-4.6). + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" +#include "tx_timer.h" + + +VOID _tx_thread_context_restore(VOID) +{ +TX_THREAD *current_thread; +TX_THREAD *execute_thread; + + _tx_win32_debug_entry_insert("CONTEXT_RESTORE", __FILE__, __LINE__); + + _tx_thread_system_state[0]--; + current_thread = _tx_thread_current_ptr[0]; + execute_thread = _tx_thread_execute_ptr[0]; + + if (_tx_thread_system_state[0] == 0UL) + { + if (current_thread != TX_NULL) + { + if ((_tx_thread_preempt_disable == 0U) && (current_thread != execute_thread)) + { + /* If context_save skipped SuspendThread because the thread was spinning + * on the Win32 CS (suspension_type == 4), suspend it now. The ISR still + * holds the CS so the spinning thread cannot make forward progress, making + * SuspendThread safe to call here. mutex_access remains TRUE; the thread + * will clear it naturally when it acquires the CS after being resumed. */ + if (current_thread -> tx_thread_win32_suspension_type == 4U) + { + _tx_win32_thread_suspend(current_thread -> tx_thread_win32_thread_handle); + } + + current_thread -> tx_thread_win32_suspension_type = 1U; + + if (_tx_timer_time_slice[0] != 0U) + { + current_thread -> tx_thread_time_slice = _tx_timer_time_slice[0]; + _tx_timer_time_slice[0] = 0U; + } + + _tx_thread_current_ptr[0] = TX_NULL; + _tx_win32_virtual_cores[0].tx_thread_smp_core_mapping_thread_handle = NULL; + _tx_win32_virtual_cores[0].tx_thread_smp_core_mapping_thread_id = 0U; + _tx_win32_virtual_cores[0].tx_thread_smp_core_mapping_thread = TX_NULL; + current_thread -> tx_thread_smp_core_control = 1U; + + /* Signal the scheduler to assign the next execute_thread. Wait for the + * scheduler to signal isr_semaphore before returning: the scheduler holds + * the CS while waiting for start_ack from the execute_thread, which forces + * any thread calling TX_DISABLE to spin with mutex_access=TRUE while + * preempt_disable may be non-zero — exactly the window needed to satisfy + * the condition in tests such as wait_abort_and_isr. */ + _tx_win32_timer_waiting = 1U; + MemoryBarrier(); + if (SetEvent(_tx_win32_scheduler_event) == 0) + { + _tx_win32_system_error++; + } + + if ((execute_thread != TX_NULL) && + (execute_thread -> tx_thread_win32_suspension_type == 2U)) + { + _tx_win32_critical_section_release_all(&_tx_win32_critical_section); + _tx_win32_wait_for_isr_rendezvous(); + _tx_win32_critical_section_obtain(&_tx_win32_critical_section); + _tx_win32_semaphore_reset(_tx_win32_isr_semaphore); + } + + _tx_win32_timer_waiting = 0U; + } + else + { + if ((current_thread -> tx_thread_win32_suspension_type == 3U) || + (current_thread -> tx_thread_win32_suspension_type == 4U)) + { + /* context_save did not call SuspendThread (type 3: preempt_disable≠0; + * type 4: thread was spinning on Win32 CS). Clear the flag; do not + * issue a matching ResumeThread. The thread will continue + * automatically once the ISR releases the Win32 critical section. */ + current_thread -> tx_thread_win32_suspension_type = 0U; + } + else + { + /* suspension_type 0: context_save called SuspendThread. Always issue + * the matching ResumeThread here, regardless of mutex_access. + * + * Do NOT gate this on mutex_access: a thread on a different virtual core + * that happens to share the same stale TLS slot can momentarily stamp + * mutex_access = TRUE on this thread's struct while it is OS-suspended, + * which would otherwise cause context_restore to skip ResumeThread and + * leave the thread permanently suspended (deadlock). */ + _tx_win32_thread_resume(current_thread -> tx_thread_win32_thread_handle); + } + } + } + else if (execute_thread != TX_NULL) + { + _tx_win32_timer_waiting = 1U; + MemoryBarrier(); + if (SetEvent(_tx_win32_scheduler_event) == 0) + { + _tx_win32_system_error++; + } + + if (execute_thread -> tx_thread_win32_suspension_type == 2U) + { + _tx_win32_critical_section_release_all(&_tx_win32_critical_section); + _tx_win32_wait_for_isr_rendezvous(); + _tx_win32_critical_section_obtain(&_tx_win32_critical_section); + _tx_win32_semaphore_reset(_tx_win32_isr_semaphore); + } + + _tx_win32_timer_waiting = 0U; + } + } + + _tx_thread_smp_unprotect(TX_INT_ENABLE); +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_context_save.c b/ports_smp/win64/vs_2022/src/tx_thread_context_save.c new file mode 100644 index 00000000..89d6cd75 --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_context_save.c @@ -0,0 +1,83 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +// Some portions generated by Codex (gpt 5.4). +// Some portions generated by GitHub Copilot (claude-sonnet-4.6). + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" +#include "tx_timer.h" + +VOID _tx_thread_context_save(VOID) +{ +TX_THREAD *thread_ptr; +UINT interrupt_posture; + + interrupt_posture = _tx_thread_smp_protect(); + if (interrupt_posture != TX_FALSE) + { + _tx_win32_system_error++; + } + + _tx_win32_debug_entry_insert("CONTEXT_SAVE", __FILE__, __LINE__); + + thread_ptr = _tx_thread_current_ptr[0]; + + if ((thread_ptr != TX_NULL) && (_tx_thread_system_state[0] == 0UL)) + { + if (thread_ptr -> tx_thread_win32_mutex_access == TX_FALSE) + { + if (_tx_thread_preempt_disable == 0U) + { + /* Thread is not in a preempt-disabled section; suspend it normally so + * context_restore can preempt it if a higher-priority thread is ready. */ + _tx_win32_thread_suspend(thread_ptr -> tx_thread_win32_thread_handle); + _tx_win32_debug_entry_insert("CONTEXT_SAVE-suspend_thread", __FILE__, __LINE__); + } + else + { + /* Thread holds the SMP preemption lock (_tx_thread_preempt_disable != 0). + * Issuing SuspendThread/ResumeThread here would cost ~100 µs for zero + * benefit: context_restore will skip preemption anyway because + * _tx_thread_preempt_disable is still non-zero when it runs (the ISR + * cannot lower the count below its value at ISR entry while it holds the + * Win32 critical section). Flag the thread so context_restore knows not + * to issue a matching ResumeThread. + * + * MISRA C 2012 Rule 10.3 deviation: suspension_type is a UINT field used + * as a small state tag; value 3 is a port-local extension of the existing + * 0/1/2 enumeration. */ + thread_ptr -> tx_thread_win32_suspension_type = 3U; + } + } + else + { + /* Thread is spinning on the Win32 critical section (mutex_access TRUE). + * It is blocked waiting to acquire the CS and cannot execute any protected + * ThreadX code, so SuspendThread is unnecessary. Tag the thread with + * suspension_type 4 so context_restore handles it correctly: + * - no-preemption path: just clear the flag (no ResumeThread). + * - preemption path: call SuspendThread retrospectively and proceed. + * + * MISRA C 2012 Rule 10.3 deviation: value 4 is a port-local extension. */ + thread_ptr -> tx_thread_win32_suspension_type = 4U; + } + } + + _tx_thread_system_state[0]++; +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_interrupt_control.c b/ports_smp/win64/vs_2022/src/tx_thread_interrupt_control.c new file mode 100644 index 00000000..b596baeb --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_interrupt_control.c @@ -0,0 +1,104 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" + +UINT _tx_thread_interrupt_disable(void) +{ +UINT previous_value; + + previous_value = _tx_thread_interrupt_control(TX_INT_DISABLE); + return(previous_value); +} + + +VOID _tx_thread_interrupt_restore(UINT previous_posture) +{ + previous_posture = _tx_thread_interrupt_control(previous_posture); + TX_PARAMETER_NOT_USED(previous_posture); +} + + +UINT _tx_thread_interrupt_control(UINT new_posture) +{ +UINT old_posture; +TX_THREAD *thread_ptr; +DWORD thread_id; +UINT core; + + _tx_win32_critical_section_obtain(&_tx_win32_critical_section); + +#ifdef TX_WIN32_DEBUG_ENABLE + if (new_posture == TX_INT_ENABLE) + { + _tx_win32_debug_entry_insert("RESTORE", __FILE__, __LINE__); + } + else + { + _tx_win32_debug_entry_insert("DISABLE", __FILE__, __LINE__); + } +#endif + + thread_id = GetCurrentThreadId(); + core = _tx_thread_smp_core_get(); + thread_ptr = _tx_thread_current_ptr[core]; + + if ((_tx_win32_threadx_thread != 0) && + ((thread_ptr == TX_NULL) || (thread_ptr -> tx_thread_win32_thread_id != thread_id))) + { + _tx_win32_critical_section_release_all(&_tx_win32_critical_section); + ExitThread(0); + } + + if (_tx_win32_critical_section.tx_win32_critical_section_nested_count == 1U) + { + old_posture = TX_INT_ENABLE; + } + else + { + old_posture = TX_INT_DISABLE; + } + + if (_tx_thread_system_state[core] != 0UL) + { + if (new_posture == TX_INT_ENABLE) + { + _tx_win32_global_int_disabled_flag = TX_FALSE; + _tx_win32_critical_section_release_all(&_tx_win32_critical_section); + } + else if (new_posture == TX_INT_DISABLE) + { + _tx_win32_global_int_disabled_flag = TX_TRUE; + } + } + else if (thread_ptr != TX_NULL) + { + if (new_posture == TX_INT_ENABLE) + { + thread_ptr -> tx_thread_win32_int_disabled_flag = TX_FALSE; + _tx_win32_critical_section_release_all(&_tx_win32_critical_section); + } + else if (new_posture == TX_INT_DISABLE) + { + thread_ptr -> tx_thread_win32_int_disabled_flag = TX_TRUE; + } + } + + return(old_posture); +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_schedule.c b/ports_smp/win64/vs_2022/src/tx_thread_schedule.c new file mode 100644 index 00000000..f33eb7b0 --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_schedule.c @@ -0,0 +1,261 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +// Some portions generated by Codex (gpt 5.5). + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" +#include "tx_timer.h" + +static VOID _tx_win32_thread_cleanup(TX_THREAD *thread_ptr); + +VOID _tx_thread_schedule(VOID) +{ +UINT core; +UINT pending_work; +TX_THREAD *current_thread; +TX_THREAD *execute_thread; +UCHAR preempt_retry; +DWORD wait_status; +LONG start_sequence; + + preempt_retry = TX_FALSE; + + while (1) + { + _tx_win32_critical_section_obtain(&_tx_win32_critical_section); + + if (_tx_win32_global_int_disabled_flag != TX_FALSE) + { + _tx_win32_system_error++; + } + + _tx_win32_debug_entry_insert("SCHEDULE-wake_up", __FILE__, __LINE__); + + for (core = 0U; core < TX_THREAD_SMP_MAX_CORES; core++) + { + current_thread = _tx_thread_current_ptr[core]; + + if ((current_thread != TX_NULL) && (current_thread -> tx_thread_win32_deferred_preempt != TX_FALSE)) + { + if (_tx_thread_preempt_disable != 0U) + { + preempt_retry = TX_TRUE; + continue; + } + + if (current_thread -> tx_thread_win32_mutex_access != TX_FALSE) + { + preempt_retry = TX_TRUE; + continue; + } + + if (current_thread -> tx_thread_state != TX_TERMINATED) + { + _tx_win32_thread_suspend(current_thread -> tx_thread_win32_thread_handle); + current_thread -> tx_thread_win32_deferred_preempt = TX_FALSE; + current_thread -> tx_thread_win32_suspension_type = 1U; + + if (_tx_timer_time_slice[core] != 0U) + { + current_thread -> tx_thread_time_slice = _tx_timer_time_slice[core]; + _tx_timer_time_slice[core] = 0U; + } + } + + _tx_thread_current_ptr[core] = TX_NULL; + _tx_win32_virtual_cores[core].tx_thread_smp_core_mapping_thread = TX_NULL; + _tx_win32_virtual_cores[core].tx_thread_smp_core_mapping_thread_handle = NULL; + _tx_win32_virtual_cores[core].tx_thread_smp_core_mapping_thread_id = 0U; + current_thread -> tx_thread_smp_core_control = 1U; + + _tx_win32_debug_entry_insert("SCHEDULE-core_preempt_complete", __FILE__, __LINE__); + } + + if (_tx_thread_current_ptr[core] == TX_NULL) + { + execute_thread = _tx_thread_execute_ptr[core]; + + if ((execute_thread != TX_NULL) && (execute_thread -> tx_thread_smp_core_control != 0U)) + { + _tx_thread_current_ptr[core] = execute_thread; + execute_thread -> tx_thread_win32_virtual_core = core; + execute_thread -> tx_thread_smp_core_mapped = core; + _tx_win32_virtual_cores[core].tx_thread_smp_core_mapping_thread = execute_thread; + _tx_win32_virtual_cores[core].tx_thread_smp_core_mapping_thread_handle = execute_thread -> tx_thread_win32_thread_handle; + _tx_win32_virtual_cores[core].tx_thread_smp_core_mapping_thread_id = execute_thread -> tx_thread_win32_thread_id; + execute_thread -> tx_thread_smp_core_control = 0U; + execute_thread -> tx_thread_run_count++; + _tx_timer_time_slice[core] = execute_thread -> tx_thread_time_slice; + MemoryBarrier(); + if (execute_thread -> tx_thread_win32_suspension_type == 1U) + { + execute_thread -> tx_thread_win32_suspension_type = 0U; + _tx_win32_debug_entry_insert("SCHEDULE-resume_thread", __FILE__, __LINE__); + _tx_win32_thread_resume(execute_thread -> tx_thread_win32_thread_handle); + } + else if (execute_thread -> tx_thread_win32_suspension_type == 2U) + { + execute_thread -> tx_thread_win32_suspension_type = 0U; + _tx_win32_debug_entry_insert("SCHEDULE-release_sem", __FILE__, __LINE__); + +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_mark_run_signal(execute_thread); +#endif +#if (TX_WIN32_USE_ADDRESS_WAIT == 0) + _tx_win32_semaphore_reset(execute_thread -> tx_thread_win32_thread_start_semaphore); + _tx_win32_semaphore_reset(execute_thread -> tx_thread_win32_thread_run_semaphore); +#endif + start_sequence = _tx_win32_thread_start_sequence_get(execute_thread); + _tx_win32_thread_run_signal(execute_thread); + /* Wait for the execute_thread to signal start_ack before proceeding. + * Holding the CS here means any thread that calls TX_DISABLE will + * spin with mutex_access=TRUE and preempt_disable≠0, creating the + * window the ISR needs to observe preempt_disable!=0 for resonance + * tests such as wait_abort_and_isr. */ + wait_status = _tx_win32_wait_for_thread_start_ack(execute_thread, start_sequence); + if (wait_status != WAIT_OBJECT_0) + { + _tx_win32_system_error++; + } + } + else + { + _tx_win32_system_error++; + } + } + } + } + + /* Signal context_restore's rendezvous wait now that all execute_threads have + * been resumed and their start_ack received. */ + if (_tx_win32_timer_waiting != 0U) + { + ReleaseSemaphore(_tx_win32_isr_semaphore, 1, NULL); + } + + if (preempt_retry != TX_FALSE) + { + _tx_win32_critical_section_release_all(&_tx_win32_critical_section); + _tx_win32_thread_yield(); + preempt_retry = TX_FALSE; + continue; + } + + _tx_win32_debug_entry_insert("SCHEDULE-self_suspend_sem", __FILE__, __LINE__); + + pending_work = TX_FALSE; + for (core = 0U; core < TX_THREAD_SMP_MAX_CORES; core++) + { + current_thread = _tx_thread_current_ptr[core]; + execute_thread = _tx_thread_execute_ptr[core]; + + if ((current_thread != TX_NULL) && (current_thread -> tx_thread_win32_deferred_preempt != TX_FALSE)) + { + pending_work = TX_TRUE; + break; + } + + if ((_tx_thread_current_ptr[core] == TX_NULL) && + (execute_thread != TX_NULL) && + (execute_thread -> tx_thread_smp_core_control != 0U)) + { + pending_work = TX_TRUE; + break; + } + } + + _tx_win32_critical_section_release_all(&_tx_win32_critical_section); + + if (pending_work != TX_FALSE) + { + continue; + } + + /* Coalesce stale wakeups so the scheduler yields to worker threads + until there is a new ready-state transition to process. */ + (void) _tx_win32_wait_for_scheduler_event(); + } +} + + +static VOID _tx_win32_thread_cleanup(TX_THREAD *thread_ptr) +{ +DWORD exit_code; +ULONG wait_count; + + if (thread_ptr -> tx_thread_win32_thread_handle != NULL) + { + wait_count = 0U; + + do + { + if ((GetExitCodeThread(thread_ptr -> tx_thread_win32_thread_handle, &exit_code) != 0) && + (exit_code != STILL_ACTIVE)) + { + break; + } + + _tx_win32_thread_resume(thread_ptr -> tx_thread_win32_thread_handle); + + _tx_win32_thread_run_signal(thread_ptr); + + _tx_win32_thread_sleep(1U); + wait_count++; + } while (wait_count < 100U); + + if ((GetExitCodeThread(thread_ptr -> tx_thread_win32_thread_handle, &exit_code) != 0) && + (exit_code == STILL_ACTIVE)) + { + (void) TerminateThread(thread_ptr -> tx_thread_win32_thread_handle, 0U); + (void) WaitForSingleObject(thread_ptr -> tx_thread_win32_thread_handle, INFINITE); + } + + CloseHandle(thread_ptr -> tx_thread_win32_thread_handle); + thread_ptr -> tx_thread_win32_thread_handle = NULL; + } + + if (thread_ptr -> tx_thread_win32_thread_run_semaphore != NULL) + { + CloseHandle(thread_ptr -> tx_thread_win32_thread_run_semaphore); + thread_ptr -> tx_thread_win32_thread_run_semaphore = NULL; + } + + if (thread_ptr -> tx_thread_win32_thread_start_semaphore != NULL) + { + CloseHandle(thread_ptr -> tx_thread_win32_thread_start_semaphore); + thread_ptr -> tx_thread_win32_thread_start_semaphore = NULL; + } +} + + +void _tx_thread_delete_port_completion(TX_THREAD *thread_ptr, UINT tx_interrupt_save) +{ + _tx_thread_smp_unprotect(tx_interrupt_save); + + _tx_win32_thread_cleanup(thread_ptr); + + tx_interrupt_save = _tx_thread_smp_protect(); + TX_PARAMETER_NOT_USED(tx_interrupt_save); +} + + +void _tx_thread_reset_port_completion(TX_THREAD *thread_ptr, UINT tx_interrupt_save) +{ + _tx_thread_delete_port_completion(thread_ptr, tx_interrupt_save); +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_smp_core_get.c b/ports_smp/win64/vs_2022/src/tx_thread_smp_core_get.c new file mode 100644 index 00000000..5a1698a4 --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_smp_core_get.c @@ -0,0 +1,26 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" +#include "tx_timer.h" + +UINT _tx_thread_smp_core_get(void) +{ + return(_tx_win32_smp_current_core_get()); +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_smp_core_preempt.c b/ports_smp/win64/vs_2022/src/tx_thread_smp_core_preempt.c new file mode 100644 index 00000000..2da24fda --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_smp_core_preempt.c @@ -0,0 +1,52 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +// Some portions generated by Codex (gpt 5.4). + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" +#include "tx_timer.h" + +void _tx_thread_smp_core_preempt(UINT core) +{ +TX_THREAD *preempt_thread; + + preempt_thread = _tx_thread_current_ptr[core]; + + if (preempt_thread != TX_NULL) + { + preempt_thread -> tx_thread_win32_deferred_preempt = TX_TRUE; + _tx_win32_debug_entry_insert("CORE_PREEMPT_deferred", __FILE__, __LINE__); + + MemoryBarrier(); + if (SetEvent(_tx_win32_scheduler_event) == 0) + { + _tx_win32_system_error++; + } + } + else if (_tx_thread_execute_ptr[core] != TX_NULL) + { + _tx_win32_debug_entry_insert("CORE_PREEMPT_wake_idle", __FILE__, __LINE__); + + MemoryBarrier(); + if (SetEvent(_tx_win32_scheduler_event) == 0) + { + _tx_win32_system_error++; + } + } +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_smp_current_state_get.c b/ports_smp/win64/vs_2022/src/tx_thread_smp_current_state_get.c new file mode 100644 index 00000000..bf1726df --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_smp_current_state_get.c @@ -0,0 +1,49 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +// Some portions generated by Codex (gpt 5.4). + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" +#include "tx_timer.h" + +ULONG _tx_thread_smp_current_state_get(void) +{ +UINT core; +DWORD thread_id; +UINT critical_section_owned; +ULONG current_state; + + thread_id = GetCurrentThreadId(); + critical_section_owned = (UINT) (_tx_win32_critical_section.tx_win32_critical_section_owner == thread_id); + + if (critical_section_owned == TX_FALSE) + { + _tx_win32_critical_section_obtain(&_tx_win32_critical_section); + } + + core = _tx_win32_smp_current_core_get(); + current_state = _tx_thread_system_state[core]; + + if (critical_section_owned == TX_FALSE) + { + _tx_win32_critical_section_release(&_tx_win32_critical_section); + } + + return(current_state); +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_smp_current_thread_get.c b/ports_smp/win64/vs_2022/src/tx_thread_smp_current_thread_get.c new file mode 100644 index 00000000..ade6774f --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_smp_current_thread_get.c @@ -0,0 +1,54 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +// Some portions generated by Codex (gpt 5.4). + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" +#include "tx_timer.h" + +TX_THREAD *_tx_thread_smp_current_thread_get(void) +{ +UINT core; +DWORD thread_id; +UINT critical_section_owned; +TX_THREAD *current_thread; + + thread_id = GetCurrentThreadId(); + critical_section_owned = (UINT) (_tx_win32_critical_section.tx_win32_critical_section_owner == thread_id); + + if (critical_section_owned == TX_FALSE) + { + _tx_win32_critical_section_obtain(&_tx_win32_critical_section); + } + + core = _tx_win32_smp_current_core_get(); + current_thread = _tx_thread_current_ptr[core]; + + if ((_tx_win32_threadx_thread != 0) && (current_thread == TX_NULL)) + { + _tx_win32_debug_entry_insert("CURRENT_THREAD_GET_NULL", __FILE__, __LINE__); + } + + if (critical_section_owned == TX_FALSE) + { + _tx_win32_critical_section_release(&_tx_win32_critical_section); + } + + return(current_thread); +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_smp_initialize_wait.c b/ports_smp/win64/vs_2022/src/tx_thread_smp_initialize_wait.c new file mode 100644 index 00000000..06af9a93 --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_smp_initialize_wait.c @@ -0,0 +1,25 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" +#include "tx_timer.h" + +void _tx_thread_smp_initialize_wait(void) +{ +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_smp_low_level_initialize.c b/ports_smp/win64/vs_2022/src/tx_thread_smp_low_level_initialize.c new file mode 100644 index 00000000..a2c2e25d --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_smp_low_level_initialize.c @@ -0,0 +1,26 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" +#include "tx_timer.h" + +void _tx_thread_smp_low_level_initialize(UINT number_of_cores) +{ + TX_PARAMETER_NOT_USED(number_of_cores); +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_smp_protect.c b/ports_smp/win64/vs_2022/src/tx_thread_smp_protect.c new file mode 100644 index 00000000..e59caffc --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_smp_protect.c @@ -0,0 +1,128 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +// Some portions generated by Codex (gpt 5.5). + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" +#include "tx_timer.h" + +UINT _tx_thread_smp_protect(void) +{ +DWORD current_thread_id; +UINT core; +UINT interrupt_posture; +TX_THREAD *current_thread; +UINT current_state; + + do + { + do + { + _tx_win32_critical_section_obtain(&_tx_win32_critical_section); + + current_thread_id = GetCurrentThreadId(); + core = _tx_thread_smp_core_get(); + current_thread = _tx_thread_current_ptr[core]; + + if ((_tx_win32_threadx_thread != 0) && + ((current_thread == TX_NULL) || (current_thread -> tx_thread_win32_thread_id != current_thread_id))) + { + _tx_win32_critical_section_release_all(&_tx_win32_critical_section); + ExitThread(0); + } + + if (_tx_win32_threadx_thread == 0) + { + break; + } + + if ((current_thread != TX_NULL) && (_tx_thread_preempt_disable == 0U)) + { + current_state = current_thread -> tx_thread_state; + if ((current_state == TX_TERMINATED) || (current_state == TX_COMPLETED)) + { + current_thread -> tx_thread_win32_deferred_preempt = TX_FALSE; + current_thread -> tx_thread_win32_suspension_type = 1U; + + if (_tx_timer_time_slice[core] != 0U) + { + current_thread -> tx_thread_time_slice = _tx_timer_time_slice[core]; + _tx_timer_time_slice[core] = 0U; + } + + _tx_thread_current_ptr[core] = TX_NULL; + _tx_win32_virtual_cores[core].tx_thread_smp_core_mapping_thread = TX_NULL; + _tx_win32_virtual_cores[core].tx_thread_smp_core_mapping_thread_handle = NULL; + _tx_win32_virtual_cores[core].tx_thread_smp_core_mapping_thread_id = 0U; + current_thread -> tx_thread_smp_core_control = 1U; + + _tx_win32_debug_entry_insert("SCHEDULE-thread_terminate_preempt_complete", __FILE__, __LINE__); + if (SetEvent(_tx_win32_scheduler_event) == 0) + { + _tx_win32_system_error++; + } + _tx_win32_critical_section_release_all(&_tx_win32_critical_section); + ExitThread(0); + } + } + + if ((current_thread != TX_NULL) && (current_thread -> tx_thread_win32_deferred_preempt != TX_FALSE)) + { + if (SetEvent(_tx_win32_scheduler_event) == 0) + { + _tx_win32_system_error++; + } + _tx_win32_critical_section_release_all(&_tx_win32_critical_section); + _tx_win32_thread_yield(); + } + else + { + break; + } + } while (1); + + interrupt_posture = (UINT) _tx_win32_global_int_disabled_flag; + + if (_tx_thread_smp_protection.tx_thread_smp_protect_core == core) + { + _tx_thread_smp_protection.tx_thread_smp_protect_count++; + _tx_win32_global_int_disabled_flag = TX_TRUE; + _tx_win32_debug_entry_insert("PROTECT-obtained-nested", __FILE__, __LINE__); + break; + } + else if (_tx_thread_smp_protection.tx_thread_smp_protect_core == 0xFFFFFFFFUL) + { + _tx_thread_smp_protection.tx_thread_smp_protect_in_force = TX_TRUE; + _tx_thread_smp_protection.tx_thread_smp_protect_thread = current_thread; + _tx_thread_smp_protection.tx_thread_smp_protect_core = core; + _tx_thread_smp_protection.tx_thread_smp_protect_count = 1U; + _tx_thread_smp_protection.tx_thread_smp_protect_thread_id = current_thread_id; + _tx_win32_global_int_disabled_flag = TX_TRUE; + _tx_win32_debug_entry_insert("PROTECT-obtained", __FILE__, __LINE__); + break; + } + else + { + _tx_win32_critical_section_release(&_tx_win32_critical_section); + } + } while (1); + + _tx_win32_global_int_disabled_flag = TX_TRUE; + return(interrupt_posture); +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_smp_time_get.c b/ports_smp/win64/vs_2022/src/tx_thread_smp_time_get.c new file mode 100644 index 00000000..adf4a82e --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_smp_time_get.c @@ -0,0 +1,27 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" +#include "tx_timer.h" + +ULONG _tx_thread_smp_time_get(void) +{ + QueryPerformanceCounter((LARGE_INTEGER *) &_tx_win32_time_stamp); + return((ULONG) _tx_win32_time_stamp.LowPart); +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_smp_unprotect.c b/ports_smp/win64/vs_2022/src/tx_thread_smp_unprotect.c new file mode 100644 index 00000000..b845767d --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_smp_unprotect.c @@ -0,0 +1,73 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +// Some portions generated by Codex (gpt 5.4). + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" +#include "tx_timer.h" + +void _tx_thread_smp_unprotect(UINT new_interrupt_posture) +{ +UINT core; +DWORD current_thread_id; +UINT critical_section_owned; + + current_thread_id = GetCurrentThreadId(); + critical_section_owned = (UINT) (_tx_win32_critical_section.tx_win32_critical_section_owner == current_thread_id); + + if (critical_section_owned == TX_FALSE) + { + _tx_win32_critical_section_obtain(&_tx_win32_critical_section); + } + + core = _tx_thread_smp_core_get(); + + if (_tx_thread_smp_protection.tx_thread_smp_protect_core == core) + { + _tx_thread_smp_protection.tx_thread_smp_protect_count--; + + if (_tx_thread_smp_protection.tx_thread_smp_protect_count == 0U) + { + _tx_win32_global_int_disabled_flag = new_interrupt_posture; + + if (_tx_thread_preempt_disable == 0U) + { + _tx_thread_smp_protection.tx_thread_smp_protect_in_force = TX_FALSE; + _tx_thread_smp_protection.tx_thread_smp_protect_thread = TX_NULL; + _tx_thread_smp_protection.tx_thread_smp_protect_core = 0xFFFFFFFFUL; + _tx_thread_smp_protection.tx_thread_smp_protect_thread_id = 0U; + _tx_win32_debug_entry_insert("UNPROTECT-keep", __FILE__, __LINE__); + } + else + { + _tx_win32_debug_entry_insert("UNPROTECT-released", __FILE__, __LINE__); + } + } + else + { + _tx_win32_debug_entry_insert("UNPROTECT-nested", __FILE__, __LINE__); + } + + _tx_win32_critical_section_release(&_tx_win32_critical_section); + } + else + { + _tx_win32_critical_section_release(&_tx_win32_critical_section); + } +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_stack_build.c b/ports_smp/win64/vs_2022/src/tx_thread_stack_build.c new file mode 100644 index 00000000..0531fb3b --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_stack_build.c @@ -0,0 +1,122 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +// Some portions generated by Codex (gpt 5.5). + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" + +#include <stdio.h> + +static DWORD WINAPI _tx_win32_thread_entry(LPVOID ptr); + +VOID _tx_thread_stack_build(TX_THREAD *thread_ptr, VOID (*function_ptr)(VOID)) +{ + TX_PARAMETER_NOT_USED(function_ptr); + +#if (TX_WIN32_USE_ADDRESS_WAIT != 0) + thread_ptr -> tx_thread_win32_thread_run_semaphore = NULL; + thread_ptr -> tx_thread_win32_thread_start_semaphore = NULL; +#else + thread_ptr -> tx_thread_win32_thread_run_semaphore = CreateSemaphore(NULL, 0, 0x7FFFFFFF, NULL); + if (thread_ptr -> tx_thread_win32_thread_run_semaphore == NULL) + { + printf("ThreadX SMP Win64 error creating thread run semaphore!\n"); + while (1) + { + } + } + + thread_ptr -> tx_thread_win32_thread_start_semaphore = CreateSemaphore(NULL, 0, 1, NULL); + if (thread_ptr -> tx_thread_win32_thread_start_semaphore == NULL) + { + printf("ThreadX SMP Win64 error creating thread start semaphore!\n"); + while (1) + { + } + } +#endif + + thread_ptr -> tx_thread_win32_thread_handle = CreateThread(NULL, + TX_WIN32_THREAD_STACK_SIZE, + _tx_win32_thread_entry, + (LPVOID) thread_ptr, + CREATE_SUSPENDED, + &thread_ptr -> tx_thread_win32_thread_id); + if (thread_ptr -> tx_thread_win32_thread_handle == NULL) + { + printf("ThreadX SMP Win64 error creating thread!\n"); + while (1) + { + } + } + + SetThreadPriority(thread_ptr -> tx_thread_win32_thread_handle, TX_WIN32_PRIORITY_USER_THREAD); + + thread_ptr -> tx_thread_win32_suspension_type = 2U; + thread_ptr -> tx_thread_win32_mutex_access = TX_FALSE; + thread_ptr -> tx_thread_win32_int_disabled_flag = TX_FALSE; + thread_ptr -> tx_thread_win32_deferred_preempt = TX_FALSE; + thread_ptr -> tx_thread_win32_virtual_core = 0U; + thread_ptr -> tx_thread_win32_run_sequence = 0L; + thread_ptr -> tx_thread_win32_run_sequence_seen = 0L; + thread_ptr -> tx_thread_win32_start_sequence = 0L; + + thread_ptr -> tx_thread_stack_ptr = (VOID *) (((CHAR *) thread_ptr -> tx_thread_stack_end) - 8); + *(((ULONG *) thread_ptr -> tx_thread_stack_ptr) - 1) = 0UL; + thread_ptr -> tx_thread_smp_core_control = 1U; + + ResumeThread(thread_ptr -> tx_thread_win32_thread_handle); +} + + +static DWORD WINAPI _tx_win32_thread_entry(LPVOID ptr) +{ +TX_THREAD *thread_ptr; + + thread_ptr = (TX_THREAD *) ptr; + _tx_win32_threadx_thread = 1; + + _tx_win32_debug_entry_insert("THREAD_ENTRY_wait", __FILE__, __LINE__); + _tx_win32_wait_for_thread_run(thread_ptr); +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_mark_run_wake(thread_ptr); +#endif + _tx_win32_debug_entry_insert("THREAD_ENTRY_wake", __FILE__, __LINE__); + + /* A delete/reset cleanup may wake a host thread that was never scheduled. + Only treat the wakeup as terminal if the ThreadX thread is already in a + terminal state; otherwise allow the normal startup race to complete. */ + if ((thread_ptr -> tx_thread_smp_core_control != 0U) && + ((thread_ptr -> tx_thread_state == TX_TERMINATED) || + (thread_ptr -> tx_thread_state == TX_COMPLETED))) + { + ExitThread(0U); + } + + _tx_win32_current_virtual_core = thread_ptr -> tx_thread_win32_virtual_core; +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_mark_start_ack(thread_ptr); +#endif + _tx_win32_thread_start_ack_signal(thread_ptr); + _tx_win32_debug_entry_insert("THREAD_ENTRY_ack", __FILE__, __LINE__); + + _tx_thread_shell_entry(); + + return(0U); +} diff --git a/ports_smp/win64/vs_2022/src/tx_thread_system_return.c b/ports_smp/win64/vs_2022/src/tx_thread_system_return.c new file mode 100644 index 00000000..8207f345 --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_thread_system_return.c @@ -0,0 +1,117 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +// Some portions generated by Codex (gpt 5.5). + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_thread.h" +#include "tx_timer.h" + +VOID _tx_thread_system_return(VOID) +{ +TX_THREAD *temp_thread_ptr; +UINT temp_thread_state; +UINT core; +DWORD thread_id; + + _tx_win32_critical_section_obtain(&_tx_win32_critical_section); + + core = _tx_thread_smp_core_get(); + thread_id = GetCurrentThreadId(); + + _tx_win32_debug_entry_insert("SYSTEM_RETURN", __FILE__, __LINE__); + + temp_thread_ptr = _tx_thread_current_ptr[core]; + + if ((_tx_win32_threadx_thread != 0) && + ((temp_thread_ptr == TX_NULL) || (temp_thread_ptr -> tx_thread_win32_thread_id != thread_id))) + { + _tx_win32_critical_section_release_all(&_tx_win32_critical_section); + ExitThread(0); + } + + if (_tx_timer_time_slice[core] != 0U) + { + temp_thread_ptr -> tx_thread_time_slice = _tx_timer_time_slice[core]; + _tx_timer_time_slice[core] = 0U; + } + + temp_thread_state = temp_thread_ptr -> tx_thread_state; + temp_thread_ptr -> tx_thread_win32_suspension_type = 2U; + _tx_thread_current_ptr[core] = TX_NULL; + _tx_win32_virtual_cores[core].tx_thread_smp_core_mapping_thread_handle = NULL; + _tx_win32_virtual_cores[core].tx_thread_smp_core_mapping_thread_id = 0U; + _tx_win32_virtual_cores[core].tx_thread_smp_core_mapping_thread = TX_NULL; + + _tx_win32_debug_entry_insert("SYSTEM_RETURN-release_sem", __FILE__, __LINE__); + + if (temp_thread_ptr != _tx_thread_smp_protection.tx_thread_smp_protect_thread) + { + _tx_win32_system_error++; + } + + _tx_thread_smp_protection.tx_thread_smp_protect_count = 0U; + _tx_thread_smp_protection.tx_thread_smp_protect_core = 0xFFFFFFFFUL; + _tx_thread_smp_protection.tx_thread_smp_protect_thread = TX_NULL; + _tx_thread_smp_protection.tx_thread_smp_protect_in_force = TX_FALSE; + _tx_thread_smp_protection.tx_thread_smp_protect_thread_id = 0U; + + temp_thread_ptr -> tx_thread_smp_core_control = 1U; + _tx_win32_global_int_disabled_flag = TX_FALSE; + _tx_thread_preempt_disable = 0U; + + MemoryBarrier(); + if (SetEvent(_tx_win32_scheduler_event) == 0) + { + _tx_win32_system_error++; + } + + _tx_win32_critical_section_release_all(&_tx_win32_critical_section); + + if (temp_thread_state == TX_TERMINATED) + { + ExitThread(0); + } + + _tx_win32_wait_for_thread_run(temp_thread_ptr); +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_mark_run_wake(temp_thread_ptr); +#endif + _tx_win32_current_virtual_core = temp_thread_ptr -> tx_thread_win32_virtual_core; +#ifdef TX_WIN32_PROFILE_ENABLE + _tx_win32_profile_mark_start_ack(temp_thread_ptr); +#endif + _tx_win32_thread_start_ack_signal(temp_thread_ptr); + + _tx_win32_critical_section_obtain(&_tx_win32_critical_section); + + _tx_win32_debug_entry_insert("SYSTEM_RETURN-wake_up", __FILE__, __LINE__); + + core = _tx_thread_smp_core_get(); + temp_thread_ptr = _tx_thread_current_ptr[core]; + + if ((_tx_win32_threadx_thread != 0) && + ((temp_thread_ptr == TX_NULL) || (temp_thread_ptr -> tx_thread_win32_thread_id != thread_id))) + { + _tx_win32_critical_section_release_all(&_tx_win32_critical_section); + ExitThread(0); + } + + _tx_win32_debug_entry_insert("SYSTEM_RETURN-finish", __FILE__, __LINE__); + _tx_win32_critical_section_release_all(&_tx_win32_critical_section); +} diff --git a/ports_smp/win64/vs_2022/src/tx_timer_interrupt.c b/ports_smp/win64/vs_2022/src/tx_timer_interrupt.c new file mode 100644 index 00000000..0a19d394 --- /dev/null +++ b/ports_smp/win64/vs_2022/src/tx_timer_interrupt.c @@ -0,0 +1,56 @@ +/*************************************************************************** + * Copyright (C) 2026 Eclipse ThreadX contributors + * + * This program and the accompanying materials are made available under the + * terms of the MIT License which is available at + * https://opensource.org/licenses/MIT. + * + * AI Disclosure: This file was largely AI-generated by Codex (gpt 5.4). + * The AI-generated portions may be considered public domain (CC0-1.0) + * and not subject to the project's licence. The human contributor has + * reviewed and verified that the code is correct. + * + * SPDX-License-Identifier: MIT and CC0-1.0 + **************************************************************************/ + +#define TX_SOURCE_CODE +#define TX_THREAD_SMP_SOURCE_CODE + +#include "tx_api.h" +#include "tx_timer.h" +#include "tx_thread.h" + +VOID _tx_timer_interrupt(VOID) +{ +UINT saved_posture; + + saved_posture = _tx_thread_smp_protect(); + + _tx_timer_interrupt_active++; + _tx_win32_debug_entry_insert("TIMER INTERRUPT", __FILE__, __LINE__); + + _tx_timer_system_clock++; + + if (*_tx_timer_current_ptr) + { + _tx_timer_expired = TX_TRUE; + } + else + { + _tx_timer_current_ptr++; + if (_tx_timer_current_ptr == _tx_timer_list_end) + { + _tx_timer_current_ptr = _tx_timer_list_start; + } + } + + if (_tx_timer_expired != TX_FALSE) + { + _tx_timer_expiration_process(); + } + + _tx_thread_time_slice(); + + _tx_timer_interrupt_active++; + _tx_thread_smp_unprotect(saved_posture); +} |