From be7d3a749262b3b588f08c827c84880169c0ef92 Mon Sep 17 00:00:00 2001 From: Felipe Neves Date: Tue, 24 Sep 2024 11:28:02 -0300 Subject: [PATCH] zipm: initial commit. 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 | 213 +++++++++++++ include/zipm/zipm_device_interface.h | 33 ++ src/zipm.c | 419 ++++++++++++++++++++++++++ src/zipm_node.h | 25 ++ src/zipm_node_pool.c | 37 +++ src/zipm_node_pool.h | 34 +++ src/zipm_shared_queue.c | 47 +++ src/zipm_shared_queue.h | 32 ++ tests/CMakeLists.txt | 11 + tests/boards/mps2_an521_cpu0.overlay | 47 +++ tests/prj.conf | 4 + tests/src/main.c | 113 +++++++ west.yml | 16 + zephyr/module.yml | 8 + 22 files changed, 1469 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 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..ea0deab --- /dev/null +++ b/include/zipm/zipm.h @@ -0,0 +1,213 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef __ZIPM_H +#define __ZIPM_H + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +enum zipm_event { + ZIPM_IDLE = 0, + ZIPM_DATA_PRODUCED, + ZIPM_DATA_CONSUMED, + ZIPM_DOORBELL, + ZIPM_NODE_AVAIL, +}; + +/** + * @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 + * @param e ZIPM event that just ocurred + * + * @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, enum zipm_event e); + +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 sends a doorbell signal on the shared queue + * + * @param zdev pointer to the ZIPM device + * @param shared_queue_number desired shared queue to signal doorbell + * + * @return 0 if successful, negative errno code if failure. + * + * @note this function just acts a signal raise, it will copy no data + * to the shared queue desired, it will raise the ZIPM_DOORBELL event + * and will notify the other side, put in mind that sending a doorbell + * will overwrite the previous event on the shared queue. + */ +static inline int zipm_send_doorbell(const struct device *zdev, int shared_queue_number) +{ + const struct zipm_device_api *api = + (const struct zipm_device_api *)zdev->api; + + if (api->send_doorbell == NULL) { + return -ENOSYS; + } + + return api->send_doorbell(zdev, 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..be3f364 --- /dev/null +++ b/include/zipm/zipm_device_interface.h @@ -0,0 +1,33 @@ +/* + * 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_send_doorbell_t)(const struct device *zdev, 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_send_doorbell_t send_doorbell; + zipm_flush_t flush; +}; + +#endif diff --git a/src/zipm.c b/src/zipm.c new file mode 100644 index 0000000..5e48be8 --- /dev/null +++ b/src/zipm.c @@ -0,0 +1,419 @@ +/* + * 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_alloc; + 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; +}; + +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; + + if(!data || !size) + return -EINVAL; + + if(shared_queue_number >= dev_data->noof_queues) + return -EINVAL; + + if(size > dev_data->node_pool->block_size) { + 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) { + struct zipm_node_descriptor * desc = zipm_node_pool_alloc(dev_data->node_pool); + if(!desc) { + 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; + } + + desc = zipm_node_pool_alloc(dev_data->node_pool); + if(!desc) { + LOG_ERR("No descriptor available to send data"); + return -ENOMEM; + } + } + + memcpy(&desc->memory, data, size); + desc->flags |= ZIPM_NODE_FLAGS_END; + + 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; + } + + zipm_shared_queue_set_event(sq, ZIPM_DATA_PRODUCED); + return ipm_send(dev_cfg->ipc_device, 0, 0, NULL, 0); + } + + do { + 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; + } + + struct zipm_node_descriptor * desc = zipm_node_pool_alloc(dev_data->node_pool); + if(!desc) + continue; + + LOG_DBG("Block allocated! remaining to transfer: %d", remaining); + + if(remaining < dev_data->node_pool->block_size) { + memcpy(&desc->memory, &data+copied, remaining); + copied += remaining; + desc->flags |= ZIPM_NODE_FLAGS_NEXT; + } else { + memcpy(&desc->memory, &data+copied, dev_data->node_pool->block_size); + copied += dev_data->node_pool->block_size; + desc->flags |= ZIPM_NODE_FLAGS_END; + } + + remaining -= dev_data->node_pool->block_size; + if(remaining < 0) { + 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); + + zipm_shared_queue_set_event(sq, ZIPM_DATA_PRODUCED); + 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_shared_queue *sq; + + if(!data || !size) + return -EINVAL; + + if(shared_queue_number >= dev_data->noof_queues) + return -EINVAL; + + if(size < dev_data->node_pool->block_size) { + 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; + } + + struct zipm_node_descriptor *desc = zipm_shared_queue_get(sq); + if(!desc) { + LOG_WRN("No data available, queue seems to be empty"); + return -ENOMEM; + } + + memcpy(data, &desc->memory, dev_data->node_pool->block_size); + fragmented = (desc->flags & ZIPM_NODE_FLAGS_NEXT); + if(!fragmented) { + zipm_shared_queue_set_event(sq, ZIPM_DATA_CONSUMED); + ipm_send(dev_cfg->ipc_device, 0, 0, NULL, 0); + } + + zipm_node_pool_dealloc(dev_data->node_pool, desc); + zipm_shared_queue_set_event(sq, ZIPM_NODE_AVAIL); + ipm_send(dev_cfg->ipc_device, 0, 0, NULL, 0); + + return fragmented; +} + +static int zipm_dev_send_doorbell(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_shared_queue *sq; + + 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; + } + + zipm_shared_queue_set_event(sq, ZIPM_DOORBELL); + return ipm_send(dev_cfg->ipc_device, 0, 0, NULL, 0); +} + +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; + + 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 { + desc = zipm_shared_queue_get(sq); + LOG_DBG("Deallocating block %p from shared queue %d", desc, shared_queue_number); + zipm_node_pool_dealloc(dev_data->node_pool, desc); + } while(desc != NULL); + + zipm_shared_queue_set_event(sq, ZIPM_NODE_AVAIL); + 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); +} + +static void zipm_dev_work_handler(struct k_work *work) +{ + struct zipm_device_data *dev_data = CONTAINER_OF(work, struct zipm_device_data, work); + const struct device* zdev = dev_data->self; + const struct zipm_device_config* dev_cfg = dev_data->self->config; + struct zipm_shared_queue *sq; + + 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; + } + + enum zipm_event e = zipm_shared_queue_get_event(sq); + + if(e != ZIPM_IDLE) { + sys_dnode_t *node; + 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, e); + } + } + } + + if(e == ZIPM_DOORBELL) { + zipm_shared_queue_set_event(sq, ZIPM_DOORBELL); + } + + if(e == ZIPM_NODE_AVAIL) { + k_sem_give(&dev_data->shared_queue_sem); + } + } +} + +static int zipm_dev_init(const struct device *zdev) +{ + bool valid; + struct zipm_device_data *dev_data = zdev->data; + const struct zipm_device_config *dev_cfg = zdev->config; + int ret; + + if(dev_cfg->should_alloc) { + 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]); + 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_cfg->should_alloc) { + do { + valid = zipm_node_pool_is_valid(dev_data->node_pool); + if(!valid) { + k_msleep(10); + continue; + } + + for(int i = 0 ; i < dev_data->noof_queues; i++) { + + struct zipm_shared_queue *sq = zipm_shared_queue_access((void *)dev_cfg->queues_location[i]); + if(!sq) { + LOG_ERR("Invalid shared queue!"); + continue; + } + + valid = zipm_is_shared_queue_valid(sq); + if(!valid) { + k_msleep(10); + break; + } + } + } while(valid == false); + } + + 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, zipm_dev_work_handler); + ipm_register_callback(dev_cfg->ipc_device, zipm_dev_ipm_isr, (void *)zdev); + + 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; +// .send_doorbell = zipm_dev_send_doorbell; +// .flush = zipm_dev_flush; +// }; + +// // struct zipm_device_config { +// // uint32_t *queues_location; +// // }; + +// // struct zipm_device_data { +// // int noof_queues; +// // struct zipm_shared_queue *queues; +// // struct k_sem shared_queue_sem; +// // struct k_work work; +// // }; + +// #define ZIPM_SHARED_QUEUE_ADDR_BY_IDX(idx) \ +// DT_REG_ADDR(DT_INST_PHANDLE_BY_IDX(0, shared_queues, idx)) + +// #define ZIPM_DEV_INIT(n) + +// static const uint32_t zipm_queues_add_##n[DT_INST_PROP_LEN(n, shared_queues)] = { +// DT_INST_FOREACH_PROP_ELEM(n, shared_queues, ZIPM_SHARED_QUEUE_ADDR_BY_IDX), +// }; + +// static struct zipm_shared_queue* zipm_queues_add_##n[DT_INST_PROP_LEN(n, shared_queues)]; + +// const static 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)), +// .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, block_size),nodes_quantity)), +// .should_alloc = DT_INST_PROP(n, should_alloc), +// .queues_location = &zipm_queues_add_##n[0], +// }; + +// static struct zipm_device_data zipm_dev_data_##n = { +// .noof_queues = DT_INST_PROP_LEN(n, shared_queues); + +// }; + + + +// DEVICE_DT_INST_DEFINE(n, &mf4005_init, NULL, &mf4005_data_##n, &mf4005_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..cb0eb8d --- /dev/null +++ b/src/zipm_node.h @@ -0,0 +1,25 @@ +/* + * 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) + +struct zipm_node_descriptor { + uint32_t magic_1; + uint32_t magic_2; + uint32_t flags; + sys_dnode_t link; + uint8_t memory[1]; +}; + +#endif diff --git a/src/zipm_node_pool.c b/src/zipm_node_pool.c new file mode 100644 index 0000000..54b9619 --- /dev/null +++ b/src/zipm_node_pool.c @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include "zipm_node_pool.h" + +int zipm_node_pool_initialize(uint32_t block_size, + uint32_t blocks_avail, void *shared_memory_address) +{ + return 0; +} + +struct zipm_node_pool_header *zipm_node_pool_get(void *shared_memory_address) +{ + return 0; +} + +bool zipm_node_pool_is_valid(const struct zipm_node_pool_header *h) +{ + return true; +} + +struct zipm_node_descriptor *zipm_node_pool_alloc(const struct zipm_node_pool_header *h) +{ + struct zipm_node_descriptor *node; + + return node; +} + +int zipm_node_pool_dealloc(const struct zipm_node_pool_header *h, struct zipm_node_descriptor *desc) +{ + return 0; +} + diff --git a/src/zipm_node_pool.h b/src/zipm_node_pool.h new file mode 100644 index 0000000..b635117 --- /dev/null +++ b/src/zipm_node_pool.h @@ -0,0 +1,34 @@ +/* + * 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; + uint32_t magic_2; + uint32_t control; + uint32_t block_size; + uint32_t blocks_avail; + sys_dlist_t descriptors; +}; + +int zipm_node_pool_initialize(uint32_t block_size, uint32_t blocks_avail, + void *shared_memory_address); + +struct zipm_node_pool_header *zipm_node_pool_get(void *shared_memory_address); + +bool zipm_node_pool_is_valid(const struct zipm_node_pool_header *h); + +struct zipm_node_descriptor *zipm_node_pool_alloc(const struct zipm_node_pool_header *h); +int zipm_node_pool_dealloc(const struct zipm_node_pool_header *h, struct zipm_node_descriptor *desc); + +#endif diff --git a/src/zipm_shared_queue.c b/src/zipm_shared_queue.c new file mode 100644 index 0000000..8c9860f --- /dev/null +++ b/src/zipm_shared_queue.c @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2024 Felipe Neves + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "zipm_shared_queue.h" + +int zipm_shared_queue_initialize(void *shared_memory_address) +{ + return 0; +} + +struct zipm_shared_queue *zipm_shared_queue_access(void *shared_memory_address) +{ + return NULL; +} + +bool zipm_is_shared_queue_valid(const struct zipm_shared_queue *sq) +{ + return true; +} + +struct zipm_node_descriptor *zipm_shared_queue_peek(const struct zipm_shared_queue *sq) +{ + struct zipm_node_descriptor *node = NULL; + + return node; +} + +struct zipm_node_descriptor *zipm_shared_queue_get(const struct zipm_shared_queue *sq) +{ + struct zipm_node_descriptor *node = NULL; + + return node; +} + + +int zipm_shared_queue_push(struct zipm_shared_queue *sq, const struct zipm_node_descriptor *elem) +{ + return 0; +} + +int zipm_shared_queue_set_event(struct zipm_shared_queue *sq, uint32_t event) +{ + return 0; +} diff --git a/src/zipm_shared_queue.h b/src/zipm_shared_queue.h new file mode 100644 index 0000000..abad643 --- /dev/null +++ b/src/zipm_shared_queue.h @@ -0,0 +1,32 @@ +/* + * 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 { + sys_dlist_t head; + uint32_t avail; + uint32_t event; + uint32_t control; +}; + +int zipm_shared_queue_initialize(void *shared_memory_address); +struct zipm_shared_queue *zipm_shared_queue_access(void *shared_memory_address); +bool zipm_is_shared_queue_valid(const struct zipm_shared_queue *sq); +struct zipm_node_descriptor *zipm_shared_queue_peek(const struct zipm_shared_queue *sq); +struct zipm_node_descriptor *zipm_shared_queue_get(const struct zipm_shared_queue *sq); +int zipm_shared_queue_push(struct zipm_shared_queue *sq, const struct zipm_node_descriptor *elem); +int zipm_shared_queue_set_event(struct zipm_shared_queue *sq, uint32_t event); +int zipm_shared_queue_get_event(const 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..c71d5a8 --- /dev/null +++ b/tests/CMakeLists.txt @@ -0,0 +1,11 @@ +# Copyright 2024 NXP +# +# 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..b958c50 --- /dev/null +++ b/tests/src/main.c @@ -0,0 +1,113 @@ +/* + * 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, enum zipm_event e) +{ +} + +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_no_memory) +{ + 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), -ENOMEM); + 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: .