From d0bdbb30b3b986e9f96124727adbd7b75ea56715 Mon Sep 17 00:00:00 2001 From: Felipe Neves Date: Tue, 24 Sep 2024 11:28:02 -0300 Subject: [PATCH] zipm: initial working commit. added also ping-pong sample Signed-off-by: Felipe Neves --- .github/workflows/ci.yml | 29 ++ CMakeLists.txt | 17 + Kconfig | 7 + LICENSE | 202 ++++++++++ README.rst | 49 +++ dts/bindings/zipm-message-device.yaml | 67 ++++ dts/bindings/zipm-node-pool.yaml | 35 ++ dts/bindings/zipm-shared-queue.yml | 24 ++ include/zipm/zipm.h | 180 +++++++++ include/zipm/zipm_device_interface.h | 31 ++ samples/ping-pong/README.rst | 54 +++ samples/ping-pong/rx/CMakeLists.txt | 8 + .../arduino_giga_r1_stm32h747xx_m4.conf | 8 + .../arduino_giga_r1_stm32h747xx_m4.overlay | 39 ++ samples/ping-pong/rx/prj.conf | 3 + samples/ping-pong/rx/src/main.c | 40 ++ samples/ping-pong/tx/CMakeLists.txt | 8 + .../arduino_giga_r1_stm32h747xx_m7.conf | 13 + .../arduino_giga_r1_stm32h747xx_m7.overlay | 66 ++++ samples/ping-pong/tx/prj.conf | 3 + samples/ping-pong/tx/src/main.c | 47 +++ src/zipm.c | 355 ++++++++++++++++++ src/zipm_node.h | 24 ++ src/zipm_node_pool.c | 146 +++++++ src/zipm_node_pool.h | 31 ++ src/zipm_shared_queue.c | 187 +++++++++ src/zipm_shared_queue.h | 35 ++ tests/CMakeLists.txt | 11 + tests/boards/mps2_an521_cpu0.overlay | 47 +++ tests/prj.conf | 4 + tests/src/main.c | 94 +++++ west.yml | 16 + zephyr/module.yml | 8 + 33 files changed, 1888 insertions(+) create mode 100644 .github/workflows/ci.yml create mode 100644 CMakeLists.txt create mode 100644 Kconfig create mode 100644 LICENSE create mode 100644 README.rst create mode 100644 dts/bindings/zipm-message-device.yaml create mode 100644 dts/bindings/zipm-node-pool.yaml create mode 100644 dts/bindings/zipm-shared-queue.yml create mode 100644 include/zipm/zipm.h create mode 100644 include/zipm/zipm_device_interface.h create mode 100644 samples/ping-pong/README.rst create mode 100644 samples/ping-pong/rx/CMakeLists.txt create mode 100644 samples/ping-pong/rx/boards/arduino_giga_r1_stm32h747xx_m4.conf create mode 100644 samples/ping-pong/rx/boards/arduino_giga_r1_stm32h747xx_m4.overlay create mode 100644 samples/ping-pong/rx/prj.conf create mode 100644 samples/ping-pong/rx/src/main.c create mode 100644 samples/ping-pong/tx/CMakeLists.txt create mode 100644 samples/ping-pong/tx/boards/arduino_giga_r1_stm32h747xx_m7.conf create mode 100644 samples/ping-pong/tx/boards/arduino_giga_r1_stm32h747xx_m7.overlay create mode 100644 samples/ping-pong/tx/prj.conf create mode 100644 samples/ping-pong/tx/src/main.c create mode 100644 src/zipm.c create mode 100644 src/zipm_node.h create mode 100644 src/zipm_node_pool.c create mode 100644 src/zipm_node_pool.h create mode 100644 src/zipm_shared_queue.c create mode 100644 src/zipm_shared_queue.h create mode 100644 tests/CMakeLists.txt create mode 100644 tests/boards/mps2_an521_cpu0.overlay create mode 100644 tests/prj.conf create mode 100644 tests/src/main.c create mode 100644 west.yml create mode 100644 zephyr/module.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..faad7cc --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,29 @@ +# Copyright (c) 2024, Felipe Neves +# SPDX-License-Identifier: Apache-2.0 + +name: Build + +on: [push, pull_request] + +jobs: + build: + runs-on: ubuntu-latest + container: zephyrprojectrtos/ci:latest + env: + CMAKE_PREFIX_PATH: /opt/toolchains + steps: + - name: Checkout + uses: actions/checkout@v2 + with: + submodules: recursive + path: zipm + + - name: Setup Zephyr project + uses: zephyrproject-rtos/action-zephyr-setup@v1 + with: + app-path: zipm + toolchains: arm-zephyr-eabi + + # - name: Build + # run: | + # west build -palways -barduino_giga_r1/stm32h747xx/m7 samples/mf4005_shell diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..a32c474 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,17 @@ +# Copyright (c) 2024 Felipe Neves +# SPDX-License-Identifier: Apache-2.0 + +if(CONFIG_ZIPM) + +zephyr_interface_library_named(ZIPM) +zephyr_include_directories(include) + +zephyr_library() +zephyr_library_sources(src/zipm.c) +zephyr_library_sources(src/zipm_node_pool.c) +zephyr_library_sources(src/zipm_shared_queue.c) + +zephyr_library_link_libraries(ZIPM) +target_link_libraries(ZIPM INTERFACE zephyr_interface) + +endif() # CONFIG_ZIPM diff --git a/Kconfig b/Kconfig new file mode 100644 index 0000000..528d34a --- /dev/null +++ b/Kconfig @@ -0,0 +1,7 @@ +# Copyright (c) 2024 Felipe Neves +# SPDX-License-Identifier: Apache-2.0 + +config ZIPM + bool "Enables Zephyr Inter-Processor Messaging" + help + Enables Zephyr Inter-Processor Messaging module diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.rst b/README.rst new file mode 100644 index 0000000..d6a3296 --- /dev/null +++ b/README.rst @@ -0,0 +1,49 @@ +.. _zephyr_inter_processor_message: + +ZIPM, a Zephyr RTOS friendly inter processor messaging module +############################################################# + + +Adding ZIPM to your project via ``west`` +**************************************** + +The recommended way is to use ``west`` to initialize this repository directly and +all its dependencies: + +.. code-block:: console + + $ west init -m https://github.com/uLipe/zipm + $ west update + +Alternatively you can add a local copy of this module by adding the following sections +to ``zephyr/west.yml``: + +1. In the ``manifest/remotes`` section add: + +.. code-block:: + + remotes: + - name: uLipe + url-base: https://github.com/uLipe + +2. In the ``manifest/projects`` section add: + +.. code-block:: + + - name: zipm + remote: uLipe + path: modules/lib/zipm + revision: main + +3. Save the file, and run ``west update`` from the project root to retrieve the +latest version of the library from Github, or whatever ``revision`` was + +Getting started with ZIPM +************************* +Please refer the ``samples`` folder inside of this module to see some basic use +cases of ZIPM, they were built for usage without hardware for quick getting started. + +Get in touch! +************* +If you have some questions, wants to contribute please contact me at: +ryukokki.felipe@gmail.com \ No newline at end of file diff --git a/dts/bindings/zipm-message-device.yaml b/dts/bindings/zipm-message-device.yaml new file mode 100644 index 0000000..bd80dad --- /dev/null +++ b/dts/bindings/zipm-message-device.yaml @@ -0,0 +1,67 @@ +# Copyright (c) 2024 Felipe Neves +# SPDX-License-Identifier: Apache-2.0 + +description: | + Zephyr Inter Processor Message device descriptor. Example usage: + + &shared_ram { + + #address-cells = <1>; + #size-cells = <0>; + + zipm_device: zipm_device { + compatible = "zipm,message-device"; + status = "okay"; + node-pool = <&zipm_pool>; + shared-queues = <&zipm_tx_queue &zipm_rx_queue>; + ipc = <&ipm0>; + should-init = ; + }; + + zipm_pool: zipm_pool@0 { + compatible = "zipm,node-pool"; + block-size = <32>; + nodes-quantity = <16>; + reg = <0x0>; + }; + + zipm_tx_queue: zipm_tx_queue@800 { + compatible = "zipm,shared-queue"; + reg = <0x800>; + }; + + zipm_rx_queue: zipm_rx_queue@c00 { + compatible = "zipm,shared-queue"; + reg = <0xc00>; + }; + + }; + +compatible: "zipm,message-device" + +properties: + node-pool: + required: true + type: phandle + description: | + node pool object reference + + shared-queues: + required: true + type: phandles + description: | + one or more shared queues reference + + ipc: + required: true + type: phandle + description: | + reference to the cross-core device node + + should-init: + type: boolean + description: | + if present this zipm device should also + initialize the shared memory area. + +include: [base.yaml] \ No newline at end of file diff --git a/dts/bindings/zipm-node-pool.yaml b/dts/bindings/zipm-node-pool.yaml new file mode 100644 index 0000000..614c59d --- /dev/null +++ b/dts/bindings/zipm-node-pool.yaml @@ -0,0 +1,35 @@ +# Copyright (c) 2024 Felipe Neves +# SPDX-License-Identifier: Apache-2.0 + +description: | + Zephyr Inter Processor Message memory pool descriptor. Example usage: + + &shared_ram { + + #address-cells = <1>; + #size-cells = <0>; + + zipm_pool: zipm_pool@0 { + compatible = "zipm,node-pool"; + block-size = <32>; + nodes-quantity = <16>; + reg = <0x0>; + }; + }; + +compatible: "zipm,node-pool" + +properties: + block-size: + required: true + type: int + description: | + Size in bytes of the memory block per node + + nodes-quantity: + required: true + type: int + description: | + Number of nodes available in the current pool + +include: [base.yaml] \ No newline at end of file diff --git a/dts/bindings/zipm-shared-queue.yml b/dts/bindings/zipm-shared-queue.yml new file mode 100644 index 0000000..be84f00 --- /dev/null +++ b/dts/bindings/zipm-shared-queue.yml @@ -0,0 +1,24 @@ +# Copyright (c) 2024 Felipe Neves +# SPDX-License-Identifier: Apache-2.0 + +description: | + Zephyr Inter Processor Message shared queue. Example usage for a + + &shared_ram { + #address-cells = <1>; + #size-cells = <0>; + + zipm_tx_queue: zipm_tx_queue@800 { + compatible = "zipm,shared-queue"; + reg = <0x800>; + }; + + zipm_rx_queue: zipm_rx_queue@c00 { + compatible = "zipm,shared-queue"; + reg = <0xc00>; + }; + }; + +compatible: "zipm,shared-queue" + +include: [base.yaml] \ No newline at end of file diff --git a/include/zipm/zipm.h b/include/zipm/zipm.h new file mode 100644 index 0000000..5e59779 --- /dev/null +++ b/include/zipm/zipm.h @@ -0,0 +1,180 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef __ZIPM_H +#define __ZIPM_H + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief ZIPM system callback event + * + * @param zdev pointer to the ZIPM device + * @param shared_queue_number desired shared queue to extract data + * @param user_data pointer where to user defined data + * + * @note This callback, once registered, will be called when any of + * the zipm_event occur, since ZIPM was made to work better in asynch + * communication, the application can use this callback to be aware of + * the state of a particular shared queue or memory events. + */ +typedef void (*zipm_event_callback_t)(const struct device *dev, int shared_queue_number, void *user_data); + +struct zipm_callback { + zipm_event_callback_t callback; + void *user_data; + sys_dnode_t link; +}; + +/* + * Includes the ZIPM device interface which is used to relay the API below. + */ +#include "zipm_device_interface.h" + +/** + * @brief Register a callback to be called after each zipm event + * + * @param zdev pointer to the ZIPM device + * @param cs callback structure + * @param fn function to be called + * @param user_data user defined data to pass when callback is called + * + * @return 0 if successful, negative errno code if failure. + */ +static inline int zipm_register_event_callback(const struct device *zdev, struct zipm_callback *cs, + zipm_event_callback_t fn, void *user_data) +{ + const struct zipm_device_api *api = + (const struct zipm_device_api *)zdev->api; + + if (api->register_callback== NULL) { + return -ENOSYS; + } + + return api->register_callback(zdev, cs, fn, user_data); +} + +/** + * @brief Removes a previously registered event callback + * + * @param zdev pointer to the ZIPM device + * @param cs callback structure + * + * @return 0 if successful, negative errno code if failure. + */ +static inline int zipm_remove_event_callback(const struct device *zdev, struct zipm_callback *cs) +{ + const struct zipm_device_api *api = + (const struct zipm_device_api *)zdev->api; + + if (api->remove_callback== NULL) { + return -ENOSYS; + } + + return api->remove_callback(cs); +} + +/** + * @brief Sends data to a shared queue + * + * @param zdev pointer to the ZIPM device + * @param data data to send + * @param size size in bytes of the data being sent + * @param shared_queue_number desired shared queue to put the data + * @param wait_time time, in miliseconds, to wait for storage to send + * + * @return 0 if successful, negative errno code if failure. + * + * @note This function automatically fragments the data passed by user + * if the shared queue block size is smaller than the data size, in that + * case multiple blocks are but in the queue and marked with NEXT flag + * the receiver is responsbile on the other hand to extract the data + * and reassembly it. + */ +static inline int zipm_send(const struct device *zdev, const void *data, size_t size, + int shared_queue_number, int wait_time) +{ + const struct zipm_device_api *api = + (const struct zipm_device_api *)zdev->api; + + if (api->send== NULL) { + return -ENOSYS; + } + + return api->send(zdev, data, size, shared_queue_number, wait_time); +} + +/** + * @brief Receive data from a shared queue + * + * @param zdev pointer to the ZIPM device + * @param data pointer where to store the data + * @param size size in bytes of the storage + * @param shared_queue_number desired shared queue to extract data + * + * @return 0 if extracted all the data, positive value if there is + * more data to extract from the current packet, otherwise negative + * errno code, -ENOMEM in case of queue empty. + * + * @note It is recommended to use this function combined with the event + * callback and capture the event ZIPM_DATA_PRODUCED, since this function + * is not synchronous, it will keep returning -ENOMEM immediately if the + * desired shared queue is empty. The other case is for fragmented data + * if this function return a positive value, it means the data received + * was fragmented, so user needs to call this function multiple times + * until it returns 0 or -ENOMEM to reassembly the fragmented data. + */ +static inline int zipm_receive(const struct device *zdev, void *data, size_t size, + int shared_queue_number) +{ + const struct zipm_device_api *api = + (const struct zipm_device_api *)zdev->api; + + if (api->receive == NULL) { + return -ENOSYS; + } + + return api->receive(zdev, data, size, shared_queue_number); +} + +/** + * @brief flushes the shared queue + * + * @param zdev pointer to the ZIPM device + * @param shared_queue_number desired shared queue to flush + * + * @return 0 if successful, negative errno code if failure. + * + * @note after invoked this function will raise an event of + * ZIPM_NODE_AVAIL indicating available memory on the shared + * memory pool. + */ +static inline int zipm_flush(const struct device *zdev, int shared_queue_number) +{ + const struct zipm_device_api *api = + (const struct zipm_device_api *)zdev->api; + + if (api->flush == NULL) { + return -ENOSYS; + } + + return api->flush(zdev, shared_queue_number); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/zipm/zipm_device_interface.h b/include/zipm/zipm_device_interface.h new file mode 100644 index 0000000..61d5955 --- /dev/null +++ b/include/zipm/zipm_device_interface.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef __ZIPM_DEVICE_INTERFACE_H +#define __ZIPM_DEVICE_INTERFACE_H + +/** + * @brief ZIPM driver generic API definition + */ + +typedef int (*zipm_register_event_callback_t)(const struct device *zdev, struct zipm_callback *cs, + zipm_event_callback_t fn, void *user_data); +typedef int (*zipm_remove_event_callback_t)(struct zipm_callback *cs); +typedef int (*zipm_send_t)(const struct device *zdev, const void *data, size_t size, + int shared_queue_number, int wait_time); +typedef int (*zipm_receive_t)(const struct device *zdev, void *data, size_t size, + int shared_queue_number); +typedef int (*zipm_flush_t)(const struct device *zdev, int shared_queue_number); + +struct zipm_device_api { + zipm_register_event_callback_t register_callback; + zipm_remove_event_callback_t remove_callback; + zipm_send_t send; + zipm_receive_t receive; + zipm_flush_t flush; +}; + +#endif diff --git a/samples/ping-pong/README.rst b/samples/ping-pong/README.rst new file mode 100644 index 0000000..49bb549 --- /dev/null +++ b/samples/ping-pong/README.rst @@ -0,0 +1,54 @@ +.. _zipm_ping_pong: + +ZIPM Ping Pong sample +##################### + +This sample is split into two project a tx project that uses shared queue 0 as +a doorbell, that periodically bothers the rx unit. The rx project waits for +an event on event queue 0, and when presents sends a message to the tx +unit which presents into the console + +Building and flashing +********************* + +Like a regular Zephyr application, for example conside the board +is the Arduino Giga R1, the tx runs on the M7 and rx runs on the +M4, the for the tx: + +.. code-block:: console + + $ west build -pauto -barduino_giga_r1/stm32h747xx/m7 zipm/samples/ping-pong/tx + $ west flash + +For the rx, pretty similar: + +.. code-block:: console + + $ west build -pauto -barduino_giga_r1/stm32h747xx/m4 zipm/samples/ping-pong/rx + $ west flash + +Expected Output +*************** + +Connect the console output of the tx side (for Arduino Giga R1) the USB-CDC is used, +so just connect to the host PC, and using your favorite terminal open a session, +you should see something similar on the console: + +.. code-block:: console + + *** Booting Zephyr OS build v3.7.0-2699-g9d3539d41bed *** + [00:00:00.016,000] usb_cdc_acm: Device suspended + 510: Other core said: Hello from other side! + [00:00:00.638,000] usb_cdc_acm: Device configured + 1010: Other core said: Hello from other side! + 1510: Other core said: Hello from other side! + 2010: Other core said: Hello from other side! + 2510: Other core said: Hello from other side! + 3010: Other core said: Hello from other side! + 8011: Other core said: Hello from other side! + 8511: Other core said: Hello from other side! + 9012: Other core said: Hello from other side! + 9512: Other core said: Hello from other side! + +You should see also the LED0 (if present) on your board blinking +every time an event arrives to one of the CPUs. diff --git a/samples/ping-pong/rx/CMakeLists.txt b/samples/ping-pong/rx/CMakeLists.txt new file mode 100644 index 0000000..7205c79 --- /dev/null +++ b/samples/ping-pong/rx/CMakeLists.txt @@ -0,0 +1,8 @@ +# SPDX-License-Identifier: Apache-2.0 + +cmake_minimum_required(VERSION 3.20.0) + +find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE}) +project(zipm_rx) + +target_sources(app PRIVATE src/main.c) diff --git a/samples/ping-pong/rx/boards/arduino_giga_r1_stm32h747xx_m4.conf b/samples/ping-pong/rx/boards/arduino_giga_r1_stm32h747xx_m4.conf new file mode 100644 index 0000000..9ce52b9 --- /dev/null +++ b/samples/ping-pong/rx/boards/arduino_giga_r1_stm32h747xx_m4.conf @@ -0,0 +1,8 @@ +CONFIG_SHELL=y +CONFIG_PRINTK=y +CONFIG_LOG=y + +CONFIG_SERIAL=y +CONFIG_CONSOLE=y +CONFIG_UART_CONSOLE=y +CONFIG_UART_LINE_CTRL=y diff --git a/samples/ping-pong/rx/boards/arduino_giga_r1_stm32h747xx_m4.overlay b/samples/ping-pong/rx/boards/arduino_giga_r1_stm32h747xx_m4.overlay new file mode 100644 index 0000000..8ab22a2 --- /dev/null +++ b/samples/ping-pong/rx/boards/arduino_giga_r1_stm32h747xx_m4.overlay @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +&sram4 { + #address-cells = <1>; + #size-cells = <0>; + + zipm_pool: zipm_pool@38000000 { + compatible = "zipm,node-pool"; + block-size = <32>; + nodes-quantity = <32>; + reg = <0x38000000>; + }; + + zipm_doorbell_queue: zipm_doorbell_queue@38008000 { + compatible = "zipm,shared-queue"; + reg = <0x38008000>; + }; + + zipm_tx_queue: zipm_tx_queue@38008400 { + compatible = "zipm,shared-queue"; + reg = <0x38008400>; + }; + + zipm_device0: zipm_device { + compatible = "zipm,message-device"; + status = "okay"; + node-pool = <&zipm_pool>; + shared-queues = <&zipm_doorbell_queue &zipm_tx_queue>; + ipc = <&mailbox>; + }; +}; + +&mailbox { + status = "okay"; +}; \ No newline at end of file diff --git a/samples/ping-pong/rx/prj.conf b/samples/ping-pong/rx/prj.conf new file mode 100644 index 0000000..8a0c213 --- /dev/null +++ b/samples/ping-pong/rx/prj.conf @@ -0,0 +1,3 @@ +CONFIG_ZIPM=y +CONFIG_IPM=y +CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=4096 \ No newline at end of file diff --git a/samples/ping-pong/rx/src/main.c b/samples/ping-pong/rx/src/main.c new file mode 100644 index 0000000..0005910 --- /dev/null +++ b/samples/ping-pong/rx/src/main.c @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include +#include +#include + +static const struct gpio_dt_spec led = GPIO_DT_SPEC_GET(DT_ALIAS(led0), gpios); +static const struct device *handle = DEVICE_DT_GET(DT_NODELABEL(zipm_device0)); +static struct zipm_callback callback; +static const char msg[] = {"Hello from other side!\0"}; + +const int doorbell_queue = 0; +const int tx_queue = 1; + +static void zipm_event_callback(const struct device *dev, int sq, void *user_data) +{ + if(sq == doorbell_queue) { + gpio_pin_toggle_dt(&led); + zipm_receive(dev, NULL, 0, doorbell_queue); + zipm_send(dev, &msg, sizeof(msg), tx_queue, 0); + } +} + +int main(void) +{ + zipm_register_event_callback(handle, &callback, zipm_event_callback, NULL); + if (!gpio_is_ready_dt(&led)) { + return 0; + } + + gpio_pin_configure_dt(&led, GPIO_OUTPUT_ACTIVE); + return 0; +} diff --git a/samples/ping-pong/tx/CMakeLists.txt b/samples/ping-pong/tx/CMakeLists.txt new file mode 100644 index 0000000..5289751 --- /dev/null +++ b/samples/ping-pong/tx/CMakeLists.txt @@ -0,0 +1,8 @@ +# SPDX-License-Identifier: Apache-2.0 + +cmake_minimum_required(VERSION 3.20.0) + +find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE}) +project(zipm_tx) + +target_sources(app PRIVATE src/main.c) diff --git a/samples/ping-pong/tx/boards/arduino_giga_r1_stm32h747xx_m7.conf b/samples/ping-pong/tx/boards/arduino_giga_r1_stm32h747xx_m7.conf new file mode 100644 index 0000000..3114887 --- /dev/null +++ b/samples/ping-pong/tx/boards/arduino_giga_r1_stm32h747xx_m7.conf @@ -0,0 +1,13 @@ +CONFIG_USB_DEVICE_INITIALIZE_AT_BOOT=y +CONFIG_SHELL=y +CONFIG_PRINTK=y +CONFIG_LOG=y +CONFIG_USB_DEVICE_STACK=y +CONFIG_USB_WORKQUEUE_STACK_SIZE=16384 +CONFIG_USB_DEVICE_PRODUCT="ZIPM-Arduino-TX" +CONFIG_USB_DEVICE_PID=0x0004 +CONFIG_MAIN_STACK_SIZE=8912 +CONFIG_SERIAL=y +CONFIG_CONSOLE=y +CONFIG_UART_CONSOLE=y +CONFIG_UART_LINE_CTRL=y diff --git a/samples/ping-pong/tx/boards/arduino_giga_r1_stm32h747xx_m7.overlay b/samples/ping-pong/tx/boards/arduino_giga_r1_stm32h747xx_m7.overlay new file mode 100644 index 0000000..ac2ea53 --- /dev/null +++ b/samples/ping-pong/tx/boards/arduino_giga_r1_stm32h747xx_m7.overlay @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +/ { + chosen { + zephyr,console = &cdc_acm_uart0; + zephyr,shell-uart = &cdc_acm_uart0; + zephyr,cdc-acm-uart0 = &cdc_acm_uart0; + }; +}; + +zephyr_udc0: &usbotg_fs { + pinctrl-0 = <&usb_otg_fs_dm_pa11 &usb_otg_fs_dp_pa12>; + pinctrl-names = "default"; + status = "okay"; + + cdc_acm_uart0: cdc_acm_uart0 { + compatible = "zephyr,cdc-acm-uart"; + }; +}; + +&cdc_acm_uart0 { + status = "okay"; +}; + +&sram4 { + #address-cells = <1>; + #size-cells = <0>; + + zipm_pool: zipm_pool@38000000 { + compatible = "zipm,node-pool"; + block-size = <32>; + nodes-quantity = <32>; + reg = <0x38000000>; + }; + + zipm_doorbell_queue: zipm_doorbell_queue@38008000 { + compatible = "zipm,shared-queue"; + reg = <0x38008000>; + }; + + zipm_rx_queue: zipm_rx_queue@38008400 { + compatible = "zipm,shared-queue"; + reg = <0x38008400>; + }; + + zipm_device0: zipm_device { + compatible = "zipm,message-device"; + status = "okay"; + node-pool = <&zipm_pool>; + shared-queues = <&zipm_doorbell_queue &zipm_rx_queue>; + ipc = <&mailbox>; + should-init; + }; +}; + +&mailbox { + status = "okay"; +}; + +&usart2 { + status = "disabled"; +}; \ No newline at end of file diff --git a/samples/ping-pong/tx/prj.conf b/samples/ping-pong/tx/prj.conf new file mode 100644 index 0000000..b8312dd --- /dev/null +++ b/samples/ping-pong/tx/prj.conf @@ -0,0 +1,3 @@ +CONFIG_IPM=y +CONFIG_ZIPM=y +CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=4096 \ No newline at end of file diff --git a/samples/ping-pong/tx/src/main.c b/samples/ping-pong/tx/src/main.c new file mode 100644 index 0000000..7b4cd39 --- /dev/null +++ b/samples/ping-pong/tx/src/main.c @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include +#include +#include + +static const struct gpio_dt_spec led = GPIO_DT_SPEC_GET(DT_ALIAS(led0), gpios); +static const struct device *handle = DEVICE_DT_GET(DT_NODELABEL(zipm_device0)); +static struct zipm_callback callback; +static char rx_msg[64] = {0}; + +static int rx_queue = 1; +static int doorbell_queue = 0; + +static void zipm_event_callback(const struct device *dev, int sq, void *user_data) +{ + if(sq == rx_queue) { + gpio_pin_toggle_dt(&led); + zipm_receive(handle, &rx_msg, sizeof(rx_msg), rx_queue); + printk("%lld: Other core said: %s \n", k_uptime_get(), (const char *)rx_msg); + } +} + +int main(void) +{ + zipm_register_event_callback(handle, &callback, zipm_event_callback, NULL); + + if (!gpio_is_ready_dt(&led)) { + return 0; + } + + gpio_pin_configure_dt(&led, GPIO_OUTPUT_ACTIVE); + + while(1) { + k_msleep(500); + zipm_send(handle, NULL, 0, doorbell_queue, 0); + } + + return 0; +} diff --git a/src/zipm.c b/src/zipm.c new file mode 100644 index 0000000..bf56c26 --- /dev/null +++ b/src/zipm.c @@ -0,0 +1,355 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#define DT_DRV_COMPAT zipm_message_device + +#include +#include +#include "zipm_node_pool.h" +#include "zipm_shared_queue.h" + +#define LOG_LEVEL CONFIG_LOG_DEFAULT_LEVEL +#include +LOG_MODULE_REGISTER(zipm, CONFIG_LOG_DEFAULT_LEVEL); + +struct zipm_device_config { + const struct device *ipc_device; + uint32_t node_pool_location; + uint32_t node_pool_block_size; + uint32_t node_pool_blocks_avail; + bool should_init; + uint32_t *queues_location; +}; + +struct zipm_device_data { + struct zipm_node_pool_header* node_pool; + struct device *self; + sys_dlist_t callbacks; + int noof_queues; + struct k_sem shared_queue_sem; + struct k_work work_link; +}; + +static int zipm_dev_register_event_callback(const struct device *zdev, struct zipm_callback *cs, + zipm_event_callback_t fn, void *user_data) +{ + int key; + struct zipm_device_data *dev_data = zdev->data; + + if(!cs || !fn) + return -EINVAL; + + cs->callback = fn; + cs->user_data = user_data; + + key = irq_lock(); + sys_dlist_append(&dev_data->callbacks, &cs->link); + irq_unlock(key); + + return 0; +} + +static int zipm_dev_remove_event_callback(struct zipm_callback *cs) +{ + int key; + + if(!cs) + return -EINVAL; + + key = irq_lock(); + sys_dlist_remove(&cs->link); + irq_unlock(key); + + return 0; +} + +static int zipm_dev_send(const struct device *zdev, const void *data, size_t size, + int shared_queue_number, int wait_time) +{ + int ret; + bool frag = false; + size_t remaining = size; + size_t copied = 0; + struct zipm_device_data *dev_data = zdev->data; + const struct zipm_device_config *dev_cfg = zdev->config; + struct zipm_shared_queue *sq; + struct zipm_node_descriptor desc; + uint8_t *mem; + + if(shared_queue_number >= dev_data->noof_queues) + return -EINVAL; + + if(size > dev_data->node_pool->block_size && data) { + frag = true; + } + + sq = zipm_shared_queue_access((void *)dev_cfg->queues_location[shared_queue_number]); + if(!sq) { + LOG_ERR("Invalid shared queue!"); + return -EINVAL; + } + + if(!frag) { + mem = zipm_node_pool_alloc(dev_data->node_pool); + if(!mem) { + int ret = k_sem_take(&dev_data->shared_queue_sem, K_MSEC(wait_time)); + if(ret < 0) { + LOG_ERR("Wait for available descriptor timed out"); + return ret; + } + + mem = zipm_node_pool_alloc(dev_data->node_pool); + if(!mem) { + LOG_ERR("No descriptor available to send data"); + return -ENOMEM; + } + } + + desc.addr = (uint32_t)mem; + desc.size = dev_cfg->node_pool_block_size; + if(data && size) { + memcpy(mem, data, size); + desc.flags = ZIPM_NODE_FLAGS_END; + } else { + desc.flags = (ZIPM_NODE_FLAGS_END | ZIPM_NODE_FLAGS_EMPTY); + } + + ret = zipm_shared_queue_push(sq, &desc); + if(ret < 0) { + LOG_ERR("failed to send data to the shared queue %d, error: %d", shared_queue_number, ret); + return ret; + } + + return ipm_send(dev_cfg->ipc_device, 0, 0, NULL, 0); + } + + do { + + mem = zipm_node_pool_alloc(dev_data->node_pool); + if(!mem) { + ret = k_sem_take(&dev_data->shared_queue_sem, K_MSEC(wait_time)); + if(ret < 0) { + LOG_ERR("Wait for available descriptor timed out"); + return ret; + } + + continue; + } + + LOG_DBG("Block allocated! remaining to transfer: %d", remaining); + + desc.addr = (uint32_t)mem; + desc.size = dev_cfg->node_pool_block_size; + if(remaining > desc.size) { + memcpy((void *)mem, &data+copied, remaining); + copied += remaining; + desc.flags = ZIPM_NODE_FLAGS_NEXT; + remaining -= desc.size; + } else { + memcpy((void *)mem, &data+copied, desc.size); + copied += desc.size; + desc.flags = ZIPM_NODE_FLAGS_END; + remaining = 0; + } + + ret = zipm_shared_queue_push(sq, &desc); + if(ret < 0) { + LOG_ERR("failed to send data to the shared queue %d, error: %d", shared_queue_number, ret); + return ret; + } + + } while (remaining); + return ipm_send(dev_cfg->ipc_device, 0, 0, NULL, 0); +} + +static int zipm_dev_receive(const struct device *zdev, void *data, size_t size, + int shared_queue_number) +{ + int fragmented; + struct zipm_device_data *dev_data = zdev->data; + const struct zipm_device_config *dev_cfg = zdev->config; + struct zipm_node_descriptor desc; + struct zipm_shared_queue *sq; + + if(shared_queue_number >= dev_data->noof_queues) + return -EINVAL; + + if(size < dev_cfg->node_pool_block_size && data) { + LOG_ERR("Not enough space provided to extract block of data"); + return -EINVAL; + } + + sq = zipm_shared_queue_access((void *)dev_cfg->queues_location[shared_queue_number]); + if(!sq) { + LOG_ERR("Invalid shared queue!"); + return -EINVAL; + } + + int ret = zipm_shared_queue_get(sq, &desc); + if(ret < 0) { + LOG_DBG("No data available, queue seems to be empty"); + return -ENOMEM; + } + + if(!(desc.flags & ZIPM_NODE_FLAGS_EMPTY) && data && size) { + memcpy(data, (const void *)desc.addr, desc.size); + } + + fragmented = (desc.flags & ZIPM_NODE_FLAGS_NEXT); + + zipm_node_pool_dealloc(dev_data->node_pool, (uint8_t *)desc.addr); + k_sem_give(&dev_data->shared_queue_sem); + + return fragmented; +} + +static int zipm_dev_flush(const struct device *zdev, int shared_queue_number) +{ + struct zipm_device_data *dev_data = zdev->data; + const struct zipm_device_config *dev_cfg = zdev->config; + struct zipm_node_descriptor desc; + struct zipm_shared_queue *sq; + int ret; + + if(shared_queue_number >= dev_data->noof_queues) { + return -EINVAL; + } + + sq = zipm_shared_queue_access((void *)dev_cfg->queues_location[shared_queue_number]); + if(!sq) { + LOG_ERR("Invalid shared queue!"); + return -EINVAL; + } + + do { + ret = zipm_shared_queue_get(sq, &desc); + if(!ret) { + LOG_DBG("Deallocating block %p from shared queue %d \n", (void *)desc.addr, shared_queue_number); + zipm_node_pool_dealloc(dev_data->node_pool, (uint8_t *)desc.addr); + } + } while(!ret); + + k_sem_give(&dev_data->shared_queue_sem); + return ipm_send(dev_cfg->ipc_device, 0, 0, NULL, 0); +} + +static void zipm_dev_ipm_isr(const struct device *ipcdev, void *user_data, + uint32_t id, volatile void *data) +{ + ARG_UNUSED(ipcdev); + const struct device *zdev = user_data; + struct zipm_device_data *dev_data = zdev->data; + dev_data->self = (struct device *)zdev; + k_work_submit(&dev_data->work_link); +} + +static void zipm_dev_work_handler(struct k_work *work) +{ + struct zipm_device_data *dev_data = CONTAINER_OF(work, struct zipm_device_data, work_link); + const struct device* zdev = dev_data->self; + const struct zipm_device_config* dev_cfg = dev_data->self->config; + struct zipm_shared_queue *sq; + sys_dnode_t *node; + + for(int i = 0; i < dev_data->noof_queues; i++) { + + sq = zipm_shared_queue_access((void *)dev_cfg->queues_location[i]); + if(!sq) { + LOG_ERR("Invalid shared queue!"); + continue; + } + + if(!zipm_shared_queue_has_data(sq)) + continue; + + SYS_DLIST_FOR_EACH_NODE(&dev_data->callbacks, node) { + struct zipm_callback *cb = CONTAINER_OF(node, struct zipm_callback, link); + if(cb->callback) { + cb->callback(zdev, i, cb->user_data); + } + } + } +} + +static int zipm_dev_init(const struct device *zdev) +{ + struct zipm_device_data *dev_data = zdev->data; + const struct zipm_device_config *dev_cfg = zdev->config; + int ret; + + if(dev_cfg->should_init) { + ret = zipm_node_pool_initialize(dev_cfg->node_pool_block_size, + dev_cfg->node_pool_blocks_avail, (void *)dev_cfg->node_pool_location); + + if(ret < 0) { + LOG_ERR("Failed do initialize node pool at location %p", (void *)dev_cfg->node_pool_location); + return ret; + } + + for(int i = 0 ; i < dev_data->noof_queues; i++) { + ret = zipm_shared_queue_initialize((void *)dev_cfg->queues_location[i], + dev_cfg->node_pool_blocks_avail); + if(ret < 0) { + + LOG_ERR("Failed do initialize shared queue at %p", (void *)dev_cfg->queues_location[i]); + return ret; + } + } + } + + dev_data->node_pool = zipm_node_pool_get((void *)dev_cfg->node_pool_location); + if(dev_data->node_pool == NULL) { + LOG_ERR("Invalid node pool! aborting!"); + return -ENOENT; + } + + LOG_DBG("Found node-pool at location %p", dev_data->node_pool); + LOG_DBG("Block size is %u bytes", dev_data->node_pool->block_size); + LOG_DBG("Blocks available %u", dev_data->node_pool->blocks_avail); + + k_sem_init(&dev_data->shared_queue_sem, 0, 1); + k_work_init(&dev_data->work_link, zipm_dev_work_handler); + sys_dlist_init(&dev_data->callbacks); + ipm_register_callback(dev_cfg->ipc_device, zipm_dev_ipm_isr, (void *)zdev); + ipm_set_enabled(dev_cfg->ipc_device, 1); + + return 0; +} + +static const struct zipm_device_api api = { + .register_callback = zipm_dev_register_event_callback, + .remove_callback = zipm_dev_remove_event_callback, + .send = zipm_dev_send, + .receive = zipm_dev_receive, + .flush = zipm_dev_flush, +}; + +#define SHARED_QUEUES_REG_BY_IDX(node_id, prop, idx) \ + DT_REG_ADDR(DT_PHANDLE_BY_IDX(node_id, prop, idx)) + +#define ZIPM_DEV_INIT(n) \ +static uint32_t zipm_queues_addr_##n[DT_INST_PROP_LEN(n, shared_queues)] = { \ + DT_FOREACH_PROP_ELEM_SEP(DT_INST(n, DT_DRV_COMPAT), shared_queues,SHARED_QUEUES_REG_BY_IDX, (,)) \ +}; \ + \ +static const struct zipm_device_config zipm_cfg_##n = { \ + .ipc_device = DEVICE_DT_GET(DT_INST_PROP(n, ipc)), \ + .node_pool_location = DT_REG_ADDR(DT_INST_PROP(n, node_pool)), \ + .queues_location = &zipm_queues_addr_##n[0], \ + .node_pool_location = DT_REG_ADDR(DT_INST_PROP(n, node_pool)), \ + .node_pool_block_size = DT_PROP(DT_INST_PROP(n, node_pool), block_size), \ + .node_pool_blocks_avail = DT_PROP(DT_INST_PROP(n, node_pool),nodes_quantity), \ + .should_init = DT_INST_PROP(n, should_init), \ +}; \ + \ +static struct zipm_device_data zipm_dev_data_##n = { \ + .noof_queues = DT_INST_PROP_LEN(n, shared_queues), \ +}; \ + \ +DEVICE_DT_INST_DEFINE(n, &zipm_dev_init, NULL, &zipm_dev_data_##n, &zipm_cfg_##n, \ + POST_KERNEL, CONFIG_APPLICATION_INIT_PRIORITY, &api); + +DT_INST_FOREACH_STATUS_OKAY(ZIPM_DEV_INIT) diff --git a/src/zipm_node.h b/src/zipm_node.h new file mode 100644 index 0000000..4d79dcd --- /dev/null +++ b/src/zipm_node.h @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef __ZIPM_NODE_H +#define __ZIPM_NODE_H + +#include +#include +#include + +#define ZIPM_NODE_FLAGS_END (1 << 0) +#define ZIPM_NODE_FLAGS_NEXT (1 << 1) +#define ZIPM_NODE_FLAGS_EMPTY (1 << 2) + +struct zipm_node_descriptor { + uint32_t addr; + uint32_t size; + uint32_t flags; +}; + +#endif diff --git a/src/zipm_node_pool.c b/src/zipm_node_pool.c new file mode 100644 index 0000000..271311a --- /dev/null +++ b/src/zipm_node_pool.c @@ -0,0 +1,146 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include "zipm_node_pool.h" +#include + +#define ZIPM_NODE_POOL_MAGIC_1 0x5a49504d +#define ZIPM_NODE_POOL_MAGIC_2 0x4e4f4445 +#define ZIPM_NODE_POOL_LOCK_FREE 0x4d50495a +#define ZIPM_NODE_POOL_MIN_BSIZE 16 + +static inline void zipm_node_pool_lock(volatile const struct zipm_node_pool_header *h) +{ + int key = irq_lock(); + while (!atomic_cas((atomic_val_t *)&h->control, ZIPM_NODE_POOL_LOCK_FREE, + ZIPM_NODE_POOL_MAGIC_1)) { + ; + } + irq_unlock(key); +} + +static inline void zipm_node_pool_unlock(volatile const struct zipm_node_pool_header *h) +{ + int key = irq_lock(); + atomic_set((atomic_val_t *)&h->control, ZIPM_NODE_POOL_LOCK_FREE); + irq_unlock(key); + +} + +int zipm_node_pool_initialize(uint32_t block_size, + uint32_t blocks_avail, volatile void *shared_memory_address) +{ + struct zipm_node_pool_header *h; + sys_dnode_t *d; + uint32_t addr = (uint32_t)shared_memory_address; + + if(shared_memory_address == NULL) + return -EINVAL; + + if(!block_size || !blocks_avail) + return -EINVAL; + + if(block_size < ZIPM_NODE_POOL_MIN_BSIZE) { + return -EINVAL; + } + + h = (struct zipm_node_pool_header *)shared_memory_address; + addr += (sizeof(struct zipm_node_pool_header)); + d = (sys_dnode_t *)addr; + + int key = irq_lock(); + atomic_set((atomic_t *)&h->control, 0); + h->block_size = block_size; + h->blocks_avail = blocks_avail; + sys_dlist_init(&h->descriptors); + + for(int i = 0; i < h->blocks_avail; i++) { + sys_dlist_append(&h->descriptors, d); + addr += h->block_size; + d = (sys_dnode_t *)addr; + } + + h->magic_1 = ZIPM_NODE_POOL_MAGIC_1; + h->magic_2 = ZIPM_NODE_POOL_MAGIC_2; + atomic_set((atomic_t *)&h->control, ZIPM_NODE_POOL_LOCK_FREE); + irq_unlock(key); + + return 0; +} + +struct zipm_node_pool_header *zipm_node_pool_get(volatile void *shared_memory_address) +{ + struct zipm_node_pool_header *h = (struct zipm_node_pool_header *)shared_memory_address; + + if(shared_memory_address == NULL) + return NULL; + + if(!zipm_node_pool_is_valid(h)) + return NULL; + + return h; +} + +bool zipm_node_pool_is_valid(volatile const struct zipm_node_pool_header *h) +{ + bool valid = true; + if(h == NULL) + return false; + + if(h->magic_1 != ZIPM_NODE_POOL_MAGIC_1) + valid = false; + + if(h->magic_2 != ZIPM_NODE_POOL_MAGIC_2) + valid = false; + + return valid; +} + +uint8_t *zipm_node_pool_alloc(volatile struct zipm_node_pool_header *h) +{ + sys_dnode_t *node; + + if(h == NULL) + return NULL; + + int key = irq_lock(); + zipm_node_pool_lock(h); + + node = sys_dlist_peek_head((sys_dlist_t *)&h->descriptors); + if(!node) { + zipm_node_pool_unlock(h); + irq_unlock(key); + return NULL; + } + + sys_dlist_remove(node); + zipm_node_pool_unlock(h); + irq_unlock(key); + + return (uint8_t *)node; +} + +int zipm_node_pool_dealloc(volatile struct zipm_node_pool_header *h, uint8_t *desc) +{ + sys_dnode_t *node; + + if(!h || !desc) + return -EINVAL; + + int key = irq_lock(); + + node = (sys_dnode_t *)desc; + zipm_node_pool_lock(h); + sys_dlist_append((sys_dlist_t *)&h->descriptors, node); + zipm_node_pool_unlock(h); + + irq_unlock(key); + + return 0; +} + diff --git a/src/zipm_node_pool.h b/src/zipm_node_pool.h new file mode 100644 index 0000000..3c779a7 --- /dev/null +++ b/src/zipm_node_pool.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef __ZIPM_NODE_POOL_H +#define __ZIPM_NODE_POOL_H + +#include +#include +#include +#include "zipm_node.h" + +struct zipm_node_pool_header { + uint32_t magic_1; + unsigned long control; + uint32_t blocks_avail; + uint32_t block_size; + sys_dlist_t descriptors; + uint32_t magic_2; +}; + +int zipm_node_pool_initialize(uint32_t block_size, uint32_t blocks_avail, + volatile void *shared_memory_address); +struct zipm_node_pool_header *zipm_node_pool_get(volatile void *shared_memory_address); +bool zipm_node_pool_is_valid(volatile const struct zipm_node_pool_header *h); +uint8_t *zipm_node_pool_alloc(volatile struct zipm_node_pool_header *h); +int zipm_node_pool_dealloc(volatile struct zipm_node_pool_header *h, uint8_t *desc); + +#endif diff --git a/src/zipm_shared_queue.c b/src/zipm_shared_queue.c new file mode 100644 index 0000000..d6a2df9 --- /dev/null +++ b/src/zipm_shared_queue.c @@ -0,0 +1,187 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include "zipm_shared_queue.h" + +#define ZIPM_SHARED_Q_MAGIC_1 0x5a49504d +#define ZIPM_SHARED_Q_MAGIC_2 0x51554555 + +int zipm_shared_queue_initialize(volatile void *shared_memory_address, int size) +{ + struct zipm_shared_queue *sq; + + if(!shared_memory_address) + return -EINVAL; + + if(!size) + return - EINVAL; + + sq = (struct zipm_shared_queue *)shared_memory_address; + int key = irq_lock(); + + sq->event = 0; + sq->write_idx = 0; + sq->read_idx = 0; + sq->avail = 0; + sq->end = size; + sq->magic_1 = ZIPM_SHARED_Q_MAGIC_1; + sq->magic_2 = ZIPM_SHARED_Q_MAGIC_2; + sq->descs = (struct zipm_node_descriptor *)((uint32_t)shared_memory_address + + sizeof(struct zipm_shared_queue)); + + memset(sq->descs, 0x00, sizeof(struct zipm_shared_queue) * size); + + irq_unlock(key); + + return 0; +} + +struct zipm_shared_queue *zipm_shared_queue_access(volatile void *shared_memory_address) +{ + struct zipm_shared_queue *sq; + + if(!shared_memory_address) + return NULL; + + sq = (struct zipm_shared_queue *)shared_memory_address; + if(!zipm_is_shared_queue_valid(sq)) + return NULL; + + return(sq); +} + +bool zipm_is_shared_queue_valid(volatile const struct zipm_shared_queue *sq) +{ + bool valid = true; + + if(sq == NULL) + return false; + + if(sq->magic_1 != ZIPM_SHARED_Q_MAGIC_1) + valid = false; + + if(sq->magic_2 != ZIPM_SHARED_Q_MAGIC_2) + valid = false; + + return true; +} + +int zipm_shared_queue_get(volatile struct zipm_shared_queue *sq, struct zipm_node_descriptor *desc) +{ + struct zipm_node_descriptor *descs; + int read; + int end; + int write; + int avail; + + if(!sq) + return -EINVAL; + + int key = irq_lock(); + + read = sq->read_idx; + end = sq->end; + avail = sq->avail; + write = sq->write_idx; + descs = sq->descs; + + if(!avail) { + irq_unlock(key); + return -ENOENT; + } + + desc->addr = descs[read].addr; + desc->flags = descs[read].flags; + desc->size = descs[read].size; + + read = ((read + 1) % end); + if(avail > 0) + avail--; + + atomic_set((atomic_t *)&sq->read_idx, read); + atomic_set((atomic_t *)&sq->avail, avail); + + irq_unlock(key); + + return 0; +} + +int zipm_shared_queue_push(volatile struct zipm_shared_queue *sq, const struct zipm_node_descriptor *desc) +{ + struct zipm_node_descriptor *descs; + int read; + int write; + int end; + int avail; + + if(!sq || !desc) + return -EINVAL; + + int key = irq_lock(); + + write = sq->write_idx; + read = sq->read_idx; + end = sq->end; + avail = sq->avail; + descs = sq->descs; + + if(avail == end) { + irq_unlock(key); + return -ENOENT; + } + + atomic_set((atomic_val_t *)&descs[write].addr, desc->addr); + atomic_set((atomic_val_t *)&descs[write].flags, desc->flags); + atomic_set((atomic_val_t *)&descs[write].size, desc->size); + + write = ((write + 1) % end); + if(avail < end) + avail++; + + atomic_set((atomic_t *)&sq->write_idx, write); + atomic_set((atomic_t *)&sq->avail, avail); + irq_unlock(key); + + return 0; +} + +int zipm_shared_queue_set_event(volatile struct zipm_shared_queue *sq, uint32_t event) +{ + if(!sq) + return -EINVAL; + + int key = irq_lock(); + atomic_set((atomic_t *)&sq->event, event); + irq_unlock(key); + + return 0; +} + +int zipm_shared_queue_get_event(volatile struct zipm_shared_queue *sq) +{ + uint32_t ev; + + if(!sq) + return -EINVAL; + + int key = irq_lock(); + ev = sq->event; + irq_unlock(key); + + return ev; +} + +bool zipm_shared_queue_has_data(volatile struct zipm_shared_queue *sq) +{ + int avail; + + if(!sq) + return -EINVAL; + + avail = sq->avail; + return (avail != 0); +} \ No newline at end of file diff --git a/src/zipm_shared_queue.h b/src/zipm_shared_queue.h new file mode 100644 index 0000000..53f172f --- /dev/null +++ b/src/zipm_shared_queue.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef __ZIPM_SHARED_QUEUE_H +#define __ZIPM_SHARED_QUEUE_H + +#include +#include +#include +#include "zipm_node.h" + +struct zipm_shared_queue { + uint32_t magic_1; + uint32_t write_idx; + uint32_t read_idx; + uint32_t avail; + uint32_t end; + uint32_t event; + uint32_t magic_2; + struct zipm_node_descriptor *descs; +}; + +int zipm_shared_queue_initialize(volatile void *shared_memory_address, int size); +struct zipm_shared_queue *zipm_shared_queue_access(volatile void *shared_memory_address); +bool zipm_is_shared_queue_valid(volatile const struct zipm_shared_queue *sq); +int zipm_shared_queue_get(volatile struct zipm_shared_queue *sq, struct zipm_node_descriptor *desc); +int zipm_shared_queue_push(volatile struct zipm_shared_queue *sq, const struct zipm_node_descriptor *desc); +int zipm_shared_queue_set_event(volatile struct zipm_shared_queue *sq, uint32_t event); +int zipm_shared_queue_get_event(volatile struct zipm_shared_queue *sq); +bool zipm_shared_queue_has_data(volatile struct zipm_shared_queue *sq); + +#endif \ No newline at end of file diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt new file mode 100644 index 0000000..8006380 --- /dev/null +++ b/tests/CMakeLists.txt @@ -0,0 +1,11 @@ +# Copyright 2024 Felipe Neves +# +# SPDX-License-Identifier: Apache-2.0 +# + +cmake_minimum_required(VERSION 3.20.0) + +find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE}) +project(zipm_test) +enable_language(C ASM) +target_sources(app PRIVATE src/main.c) diff --git a/tests/boards/mps2_an521_cpu0.overlay b/tests/boards/mps2_an521_cpu0.overlay new file mode 100644 index 0000000..ae4a56a --- /dev/null +++ b/tests/boards/mps2_an521_cpu0.overlay @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ +/ { + chosen { + zephyr,ipc_shm = &sramx; + zephyr,ipc = &mhu0; + }; + + sramx: memory@28180000 { + compatible = "mmio-sram"; + reg = <0x28180000 0x8000>; + }; +}; + +&sramx { + #address-cells = <1>; + #size-cells = <0>; + + zipm_pool: zipm_pool@28180000 { + compatible = "zipm,node-pool"; + block-size = <32>; + nodes-quantity = <32>; + reg = <0x28180000>; + }; + + zipm_tx_queue: zipm_tx_queue@28184000 { + compatible = "zipm,shared-queue"; + reg = <0x28184000>; + }; + + zipm_rx_queue: zipm_rx_queue@28184080 { + compatible = "zipm,shared-queue"; + reg = <0x28184080>; + }; + + zipm_device0: zipm_device { + compatible = "zipm,message-device"; + status = "okay"; + node-pool = <&zipm_pool>; + shared-queues = <&zipm_tx_queue &zipm_rx_queue>; + ipc = <&mhu0>; + should-init; + }; +}; \ No newline at end of file diff --git a/tests/prj.conf b/tests/prj.conf new file mode 100644 index 0000000..d3fa0b8 --- /dev/null +++ b/tests/prj.conf @@ -0,0 +1,4 @@ +CONFIG_PRINTK=y +CONFIG_ZIPM=y +CONFIG_ZTEST=y +CONFIG_IPM=y diff --git a/tests/src/main.c b/tests/src/main.c new file mode 100644 index 0000000..d333c26 --- /dev/null +++ b/tests/src/main.c @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include +#include +#include +#include + +void zipm_event_callback(const struct device *dev, int shared_queue_number, void *user_data) +{ +} + +static void zipm_tests_before(void *f) +{ +} + +static void zipm_tests_after(void *f) +{ +} + +ZTEST(zipm_test_suite, zipm_initialise_handler) +{ + const struct device *handle = DEVICE_DT_GET(DT_NODELABEL(zipm_device0)); + struct zipm_callback callback; + + zassert_equal(zipm_register_event_callback(handle, &callback, + zipm_event_callback, NULL), 0); + zassert_equal(callback.callback, &zipm_event_callback); + zassert_equal(callback.user_data, &callback); + zassert_equal(zipm_remove_event_callback(handle,&callback), 0); +} + +ZTEST(zipm_test_suite, send_receive) +{ + uint8_t data[] = {'Z','I','P','M'}; + uint8_t rx_data[] = {0,0,0,0}; + size_t rx_size = 0; + + const struct device *handle = DEVICE_DT_GET(DT_NODELABEL(zipm_device0)); + struct zipm_callback callback; + + zassert_equal(zipm_register_event_callback(handle, &callback, + zipm_event_callback, NULL), 0); + zassert_equal(callback.callback, &zipm_event_callback); + zassert_equal(callback.user_data, &callback); + + zassert_equal(zipm_send(handle, &data, sizeof(data), 0, 0), 0); + zassert_equal(zipm_receive(handle, &rx_data, rx_size, 0), 0); + zassert_equal(rx_size, sizeof(data)); + zassert_equal(memcmp(data, rx_data, sizeof(rx_data)), 0); + zassert_equal(zipm_flush(handle, 0), 0); + zassert_equal(zipm_remove_event_callback(handle,&callback), 0); +} + +ZTEST(zipm_test_suite, send_exaust_memory) +{ + uint8_t data[] = {'Z','I','P','M'}; + uint8_t rx_data[] = {0,0,0,0}; + size_t rx_size = 0; + int err = 0; + + const struct device *handle = DEVICE_DT_GET(DT_NODELABEL(zipm_device0)); + struct zipm_callback callback; + + zassert_equal(zipm_register_event_callback(handle, &callback, + zipm_event_callback, NULL), 0); + zassert_equal(callback.callback, &zipm_event_callback); + zassert_equal(callback.user_data, &callback); + + do { + err = zipm_send(handle, &data, sizeof(data), 0, 0); + } while(!err); + + err = 0; + + do { + err = zipm_receive(handle, &rx_data, rx_size, 0); + if(!err) { + zassert_equal(rx_size, sizeof(data)); + zassert_equal(memcmp(data, rx_data, sizeof(rx_data)), 0); + } + } while(!err); + + zassert_equal(zipm_flush(handle, 0), 0); + zassert_equal(zipm_remove_event_callback(handle,&callback), 0); +} + +ZTEST_SUITE(zipm_test_suite, NULL, NULL, zipm_tests_before, zipm_tests_after, NULL); diff --git a/west.yml b/west.yml new file mode 100644 index 0000000..aab9c0b --- /dev/null +++ b/west.yml @@ -0,0 +1,16 @@ +# Copyright (c) 2024 Felipe Neves +# SPDX-License-Identifier: Apache-2.0 + +manifest: + self: + path: lkmotor_mf4005_driver + + remotes: + - name: zephyr + url-base: https://github.com/zephyrproject-rtos + + projects: + - name: zephyr + remote: zephyr + repo-path: zephyr + revision: main diff --git a/zephyr/module.yml b/zephyr/module.yml new file mode 100644 index 0000000..c0fc661 --- /dev/null +++ b/zephyr/module.yml @@ -0,0 +1,8 @@ +# Copyright (c) 2024 Felipe Neves +# SPDX-License-Identifier: Apache-2.0 + +build: + kconfig: Kconfig + cmake: . + settings: + dts_root: .