Add XIAO Wio-SX1262 overlay; support SX12xx bandwidths (including 62.5 kHz) as default
- boards/seeed/xiao_wio_sx1262: add overlay, .conf, board.yml - app: support full set of SX12xx bandwidths; default BW set to 62 (62.5 kHz) - Update Kconfig and prj.conf - Update lora_modem.h/c for validation and mapping
This commit is contained in:
9
build/zephyr/include/generated/app_data_alignment.ld
Normal file
9
build/zephyr/include/generated/app_data_alignment.ld
Normal file
@@ -0,0 +1,9 @@
|
||||
/*
|
||||
* Copyright (c) 2017 Linaro Limited.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/* Set initial alignment to the 32 byte minimum for all MPUs */
|
||||
_app_data_align = 32;
|
||||
. = ALIGN(32);
|
||||
38
build/zephyr/include/generated/app_smem.ld
Normal file
38
build/zephyr/include/generated/app_smem.ld
Normal file
@@ -0,0 +1,38 @@
|
||||
/* SPDX-License-Identifier: Apache-2.0 */
|
||||
|
||||
/*
|
||||
* This hackish way of including files is due to CMake issues:
|
||||
* https://gitlab.kitware.com/cmake/cmake/issues/11985
|
||||
* https://gitlab.kitware.com/cmake/cmake/issues/13718
|
||||
*
|
||||
* When using the "Unix Makefiles" generator, CMake simply
|
||||
* greps for "#include" to generate dependency list.
|
||||
* So if doing it normally, both files are being included
|
||||
* in the dependency list. This creates weird dependency
|
||||
* issue:
|
||||
*
|
||||
* 1. Using A.ld to create a linker script A.cmd.
|
||||
* 2. Using A.cmd to generate A_prebuilt.elf.
|
||||
* 3. Using A_prebuilt.elf to create B.ld.
|
||||
* 4. Creating B.cmd with B.ld.
|
||||
* 5. Creating B_prebuilt.elf using B.cmd.
|
||||
*
|
||||
* Since the dependency list of A.cmd contains both
|
||||
* A.ld and B.ld, when make is invoked again, B.ld
|
||||
* is newer than A.cmd so everything from this point on
|
||||
* gets rebuilt. In order to break this cycle, this
|
||||
* hackish needs to be used since CMake does not parse
|
||||
* macros, and thus these will not appear in
|
||||
* the dependency list. The dependencies should then be
|
||||
* put in CMakeLists.txt instead.
|
||||
*
|
||||
* Note: Ninja generator does not suffer from this issue.
|
||||
*/
|
||||
#ifdef LINKER_APP_SMEM_UNALIGNED
|
||||
#define APP_SMEM_LD <app_smem_unaligned.ld>
|
||||
#else
|
||||
#define APP_SMEM_LD <app_smem_aligned.ld>
|
||||
#endif
|
||||
|
||||
#include APP_SMEM_LD
|
||||
#undef APP_SMEM_LD
|
||||
3
build/zephyr/include/generated/app_smem_aligned.ld
Normal file
3
build/zephyr/include/generated/app_smem_aligned.ld
Normal file
@@ -0,0 +1,3 @@
|
||||
/* SPDX-License-Identifier: Apache-2.0 */
|
||||
|
||||
/* Empty file */
|
||||
3
build/zephyr/include/generated/app_smem_unaligned.ld
Normal file
3
build/zephyr/include/generated/app_smem_unaligned.ld
Normal file
@@ -0,0 +1,3 @@
|
||||
/* SPDX-License-Identifier: Apache-2.0 */
|
||||
|
||||
/* Empty file */
|
||||
1
build/zephyr/include/generated/core-isa-dM.c
Normal file
1
build/zephyr/include/generated/core-isa-dM.c
Normal file
@@ -0,0 +1 @@
|
||||
#include <xtensa/config/core-isa.h>
|
||||
186
build/zephyr/include/generated/device-api-sections.cmake
Normal file
186
build/zephyr/include/generated/device-api-sections.cmake
Normal file
@@ -0,0 +1,186 @@
|
||||
list(APPEND sections "{NAME\;gpio_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;gpio_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._gpio_driver_api.static.*\;SYMBOLS\;_gpio_driver_api_list_start\;_gpio_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;spi_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;spi_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._spi_driver_api.static.*\;SYMBOLS\;_spi_driver_api_list_start\;_spi_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;shared_irq_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;shared_irq_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._shared_irq_driver_api.static.*\;SYMBOLS\;_shared_irq_driver_api_list_start\;_shared_irq_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;crypto_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;crypto_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._crypto_driver_api.static.*\;SYMBOLS\;_crypto_driver_api_list_start\;_crypto_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;adc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;adc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._adc_driver_api.static.*\;SYMBOLS\;_adc_driver_api_list_start\;_adc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;auxdisplay_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;auxdisplay_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._auxdisplay_driver_api.static.*\;SYMBOLS\;_auxdisplay_driver_api_list_start\;_auxdisplay_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;bbram_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;bbram_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._bbram_driver_api.static.*\;SYMBOLS\;_bbram_driver_api_list_start\;_bbram_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;biometric_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;biometric_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._biometric_driver_api.static.*\;SYMBOLS\;_biometric_driver_api_list_start\;_biometric_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;bt_hci_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;bt_hci_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._bt_hci_driver_api.static.*\;SYMBOLS\;_bt_hci_driver_api_list_start\;_bt_hci_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;can_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;can_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._can_driver_api.static.*\;SYMBOLS\;_can_driver_api_list_start\;_can_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;cellular_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;cellular_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._cellular_driver_api.static.*\;SYMBOLS\;_cellular_driver_api_list_start\;_cellular_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;charger_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;charger_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._charger_driver_api.static.*\;SYMBOLS\;_charger_driver_api_list_start\;_charger_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;clock_control_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;clock_control_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._clock_control_driver_api.static.*\;SYMBOLS\;_clock_control_driver_api_list_start\;_clock_control_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;comparator_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;comparator_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._comparator_driver_api.static.*\;SYMBOLS\;_comparator_driver_api_list_start\;_comparator_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;coredump_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;coredump_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._coredump_driver_api.static.*\;SYMBOLS\;_coredump_driver_api_list_start\;_coredump_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;counter_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;counter_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._counter_driver_api.static.*\;SYMBOLS\;_counter_driver_api_list_start\;_counter_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;crc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;crc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._crc_driver_api.static.*\;SYMBOLS\;_crc_driver_api_list_start\;_crc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;dac_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;dac_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._dac_driver_api.static.*\;SYMBOLS\;_dac_driver_api_list_start\;_dac_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;dai_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;dai_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._dai_driver_api.static.*\;SYMBOLS\;_dai_driver_api_list_start\;_dai_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;display_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;display_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._display_driver_api.static.*\;SYMBOLS\;_display_driver_api_list_start\;_display_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;dma_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;dma_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._dma_driver_api.static.*\;SYMBOLS\;_dma_driver_api_list_start\;_dma_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;edac_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;edac_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._edac_driver_api.static.*\;SYMBOLS\;_edac_driver_api_list_start\;_edac_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;eeprom_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;eeprom_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._eeprom_driver_api.static.*\;SYMBOLS\;_eeprom_driver_api_list_start\;_eeprom_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;emul_bbram_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;emul_bbram_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._emul_bbram_driver_api.static.*\;SYMBOLS\;_emul_bbram_driver_api_list_start\;_emul_bbram_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;fuel_gauge_emul_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;fuel_gauge_emul_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._fuel_gauge_emul_driver_api.static.*\;SYMBOLS\;_fuel_gauge_emul_driver_api_list_start\;_fuel_gauge_emul_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;emul_sensor_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;emul_sensor_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._emul_sensor_driver_api.static.*\;SYMBOLS\;_emul_sensor_driver_api_list_start\;_emul_sensor_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;entropy_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;entropy_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._entropy_driver_api.static.*\;SYMBOLS\;_entropy_driver_api_list_start\;_entropy_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;espi_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;espi_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._espi_driver_api.static.*\;SYMBOLS\;_espi_driver_api_list_start\;_espi_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;espi_saf_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;espi_saf_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._espi_saf_driver_api.static.*\;SYMBOLS\;_espi_saf_driver_api_list_start\;_espi_saf_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;flash_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;flash_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._flash_driver_api.static.*\;SYMBOLS\;_flash_driver_api_list_start\;_flash_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;fpga_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;fpga_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._fpga_driver_api.static.*\;SYMBOLS\;_fpga_driver_api_list_start\;_fpga_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;fuel_gauge_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;fuel_gauge_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._fuel_gauge_driver_api.static.*\;SYMBOLS\;_fuel_gauge_driver_api_list_start\;_fuel_gauge_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;gnss_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;gnss_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._gnss_driver_api.static.*\;SYMBOLS\;_gnss_driver_api_list_start\;_gnss_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;haptics_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;haptics_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._haptics_driver_api.static.*\;SYMBOLS\;_haptics_driver_api_list_start\;_haptics_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;hwspinlock_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;hwspinlock_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._hwspinlock_driver_api.static.*\;SYMBOLS\;_hwspinlock_driver_api_list_start\;_hwspinlock_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;i2c_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;i2c_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._i2c_driver_api.static.*\;SYMBOLS\;_i2c_driver_api_list_start\;_i2c_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;i2c_target_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;i2c_target_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._i2c_target_driver_api.static.*\;SYMBOLS\;_i2c_target_driver_api_list_start\;_i2c_target_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;i2s_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;i2s_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._i2s_driver_api.static.*\;SYMBOLS\;_i2s_driver_api_list_start\;_i2s_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;i3c_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;i3c_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._i3c_driver_api.static.*\;SYMBOLS\;_i3c_driver_api_list_start\;_i3c_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;ipm_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;ipm_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._ipm_driver_api.static.*\;SYMBOLS\;_ipm_driver_api_list_start\;_ipm_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;led_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;led_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._led_driver_api.static.*\;SYMBOLS\;_led_driver_api_list_start\;_led_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;led_strip_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;led_strip_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._led_strip_driver_api.static.*\;SYMBOLS\;_led_strip_driver_api_list_start\;_led_strip_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;lora_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;lora_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._lora_driver_api.static.*\;SYMBOLS\;_lora_driver_api_list_start\;_lora_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;mbox_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;mbox_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._mbox_driver_api.static.*\;SYMBOLS\;_mbox_driver_api_list_start\;_mbox_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;mdio_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;mdio_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._mdio_driver_api.static.*\;SYMBOLS\;_mdio_driver_api_list_start\;_mdio_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;mipi_dbi_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;mipi_dbi_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._mipi_dbi_driver_api.static.*\;SYMBOLS\;_mipi_dbi_driver_api_list_start\;_mipi_dbi_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;mipi_dsi_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;mipi_dsi_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._mipi_dsi_driver_api.static.*\;SYMBOLS\;_mipi_dsi_driver_api_list_start\;_mipi_dsi_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;mspi_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;mspi_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._mspi_driver_api.static.*\;SYMBOLS\;_mspi_driver_api_list_start\;_mspi_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;opamp_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;opamp_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._opamp_driver_api.static.*\;SYMBOLS\;_opamp_driver_api_list_start\;_opamp_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;otp_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;otp_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._otp_driver_api.static.*\;SYMBOLS\;_otp_driver_api_list_start\;_otp_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;peci_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;peci_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._peci_driver_api.static.*\;SYMBOLS\;_peci_driver_api_list_start\;_peci_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;ps2_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;ps2_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._ps2_driver_api.static.*\;SYMBOLS\;_ps2_driver_api_list_start\;_ps2_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;ptp_clock_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;ptp_clock_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._ptp_clock_driver_api.static.*\;SYMBOLS\;_ptp_clock_driver_api_list_start\;_ptp_clock_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;pwm_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;pwm_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._pwm_driver_api.static.*\;SYMBOLS\;_pwm_driver_api_list_start\;_pwm_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;regulator_parent_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;regulator_parent_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._regulator_parent_driver_api.static.*\;SYMBOLS\;_regulator_parent_driver_api_list_start\;_regulator_parent_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;regulator_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;regulator_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._regulator_driver_api.static.*\;SYMBOLS\;_regulator_driver_api_list_start\;_regulator_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;reset_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;reset_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._reset_driver_api.static.*\;SYMBOLS\;_reset_driver_api_list_start\;_reset_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;retained_mem_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;retained_mem_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._retained_mem_driver_api.static.*\;SYMBOLS\;_retained_mem_driver_api_list_start\;_retained_mem_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;rtc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;rtc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._rtc_driver_api.static.*\;SYMBOLS\;_rtc_driver_api_list_start\;_rtc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;sdhc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;sdhc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._sdhc_driver_api.static.*\;SYMBOLS\;_sdhc_driver_api_list_start\;_sdhc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;sensor_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;sensor_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._sensor_driver_api.static.*\;SYMBOLS\;_sensor_driver_api_list_start\;_sensor_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;smbus_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;smbus_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._smbus_driver_api.static.*\;SYMBOLS\;_smbus_driver_api_list_start\;_smbus_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;syscon_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;syscon_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._syscon_driver_api.static.*\;SYMBOLS\;_syscon_driver_api_list_start\;_syscon_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;tee_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;tee_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._tee_driver_api.static.*\;SYMBOLS\;_tee_driver_api_list_start\;_tee_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;uaol_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;uaol_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._uaol_driver_api.static.*\;SYMBOLS\;_uaol_driver_api_list_start\;_uaol_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;video_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;video_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._video_driver_api.static.*\;SYMBOLS\;_video_driver_api_list_start\;_video_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;virtio_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;virtio_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._virtio_driver_api.static.*\;SYMBOLS\;_virtio_driver_api_list_start\;_virtio_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;w1_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;w1_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._w1_driver_api.static.*\;SYMBOLS\;_w1_driver_api_list_start\;_w1_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;wdt_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;wdt_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._wdt_driver_api.static.*\;SYMBOLS\;_wdt_driver_api_list_start\;_wdt_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;wuc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;wuc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._wuc_driver_api.static.*\;SYMBOLS\;_wuc_driver_api_list_start\;_wuc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;can_transceiver_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;can_transceiver_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._can_transceiver_driver_api.static.*\;SYMBOLS\;_can_transceiver_driver_api_list_start\;_can_transceiver_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;nrf_clock_control_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;nrf_clock_control_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._nrf_clock_control_driver_api.static.*\;SYMBOLS\;_nrf_clock_control_driver_api_list_start\;_nrf_clock_control_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;i3c_target_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;i3c_target_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._i3c_target_driver_api.static.*\;SYMBOLS\;_i3c_target_driver_api_list_start\;_i3c_target_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;its_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;its_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._its_driver_api.static.*\;SYMBOLS\;_its_driver_api_list_start\;_its_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;vtd_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;vtd_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._vtd_driver_api.static.*\;SYMBOLS\;_vtd_driver_api_list_start\;_vtd_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;renesas_elc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;renesas_elc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._renesas_elc_driver_api.static.*\;SYMBOLS\;_renesas_elc_driver_api_list_start\;_renesas_elc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;tgpio_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;tgpio_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._tgpio_driver_api.static.*\;SYMBOLS\;_tgpio_driver_api_list_start\;_tgpio_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;pcie_ctrl_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;pcie_ctrl_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._pcie_ctrl_driver_api.static.*\;SYMBOLS\;_pcie_ctrl_driver_api_list_start\;_pcie_ctrl_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;pcie_ep_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;pcie_ep_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._pcie_ep_driver_api.static.*\;SYMBOLS\;_pcie_ep_driver_api_list_start\;_pcie_ep_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;psi5_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;psi5_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._psi5_driver_api.static.*\;SYMBOLS\;_psi5_driver_api_list_start\;_psi5_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;sent_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;sent_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._sent_driver_api.static.*\;SYMBOLS\;_sent_driver_api_list_start\;_sent_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;svc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;svc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._svc_driver_api.static.*\;SYMBOLS\;_svc_driver_api_list_start\;_svc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;stepper_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;stepper_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._stepper_driver_api.static.*\;SYMBOLS\;_stepper_driver_api_list_start\;_stepper_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;stepper_ctrl_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;stepper_ctrl_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._stepper_ctrl_driver_api.static.*\;SYMBOLS\;_stepper_ctrl_driver_api_list_start\;_stepper_ctrl_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;uart_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;uart_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._uart_driver_api.static.*\;SYMBOLS\;_uart_driver_api_list_start\;_uart_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;bc12_emul_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;bc12_emul_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._bc12_emul_driver_api.static.*\;SYMBOLS\;_bc12_emul_driver_api_list_start\;_bc12_emul_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;bc12_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;bc12_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._bc12_driver_api.static.*\;SYMBOLS\;_bc12_driver_api_list_start\;_bc12_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;usbc_ppc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;usbc_ppc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._usbc_ppc_driver_api.static.*\;SYMBOLS\;_usbc_ppc_driver_api_list_start\;_usbc_ppc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;tcpc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;tcpc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._tcpc_driver_api.static.*\;SYMBOLS\;_tcpc_driver_api_list_start\;_tcpc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;usbc_vbus_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;usbc_vbus_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._usbc_vbus_driver_api.static.*\;SYMBOLS\;_usbc_vbus_driver_api_list_start\;_usbc_vbus_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;ivshmem_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;ivshmem_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._ivshmem_driver_api.static.*\;SYMBOLS\;_ivshmem_driver_api_list_start\;_ivshmem_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;ethphy_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;ethphy_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._ethphy_driver_api.static.*\;SYMBOLS\;_ethphy_driver_api_list_start\;_ethphy_driver_api_list_end}")
|
||||
set(DEVICE_API_SECTIONS "${sections}" CACHE INTERNAL "")
|
||||
set(DEVICE_API_SECTION_SETTINGS "${section_settings}" CACHE INTERNAL "")
|
||||
92
build/zephyr/include/generated/device-api-sections.ld
Normal file
92
build/zephyr/include/generated/device-api-sections.ld
Normal file
@@ -0,0 +1,92 @@
|
||||
ITERABLE_SECTION_ROM(gpio_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(spi_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(shared_irq_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(crypto_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(adc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(auxdisplay_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(bbram_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(biometric_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(bt_hci_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(can_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(cellular_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(charger_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(clock_control_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(comparator_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(coredump_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(counter_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(crc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(dac_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(dai_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(display_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(dma_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(edac_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(eeprom_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(emul_bbram_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(fuel_gauge_emul_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(emul_sensor_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(entropy_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(espi_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(espi_saf_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(flash_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(fpga_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(fuel_gauge_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(gnss_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(haptics_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(hwspinlock_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(i2c_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(i2c_target_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(i2s_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(i3c_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(ipm_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(led_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(led_strip_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(lora_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(mbox_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(mdio_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(mipi_dbi_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(mipi_dsi_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(mspi_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(opamp_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(otp_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(peci_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(ps2_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(ptp_clock_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(pwm_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(regulator_parent_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(regulator_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(reset_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(retained_mem_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(rtc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(sdhc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(sensor_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(smbus_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(syscon_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(tee_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(uaol_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(video_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(virtio_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(w1_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(wdt_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(wuc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(can_transceiver_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(nrf_clock_control_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(i3c_target_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(its_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(vtd_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(renesas_elc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(tgpio_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(pcie_ctrl_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(pcie_ep_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(psi5_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(sent_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(svc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(stepper_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(stepper_ctrl_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(uart_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(bc12_emul_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(bc12_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(usbc_ppc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(tcpc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(usbc_vbus_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(ivshmem_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(ethphy_driver_api, 4)
|
||||
0
build/zephyr/include/generated/snippets-noinit.ld
Normal file
0
build/zephyr/include/generated/snippets-noinit.ld
Normal file
0
build/zephyr/include/generated/snippets-rodata.ld
Normal file
0
build/zephyr/include/generated/snippets-rodata.ld
Normal file
0
build/zephyr/include/generated/snippets-rwdata.ld
Normal file
0
build/zephyr/include/generated/snippets-rwdata.ld
Normal file
1
build/zephyr/include/generated/snippets-sections.ld
Normal file
1
build/zephyr/include/generated/snippets-sections.ld
Normal file
@@ -0,0 +1 @@
|
||||
/* Sort key: "default" */#include "zephyr/linker/intlist.ld"
|
||||
662
build/zephyr/include/generated/syscall_list.h
Normal file
662
build/zephyr/include/generated/syscall_list.h
Normal file
@@ -0,0 +1,662 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef ZEPHYR_SYSCALL_LIST_H
|
||||
#define ZEPHYR_SYSCALL_LIST_H
|
||||
|
||||
#define K_SYSCALL_DEVICE_DEINIT 0
|
||||
#define K_SYSCALL_DEVICE_GET_BINDING 1
|
||||
#define K_SYSCALL_DEVICE_GET_BY_DT_NODELABEL 2
|
||||
#define K_SYSCALL_DEVICE_INIT 3
|
||||
#define K_SYSCALL_DEVICE_IS_READY 4
|
||||
#define K_SYSCALL_GPIO_GET_PENDING_INT 5
|
||||
#define K_SYSCALL_GPIO_PIN_CONFIGURE 6
|
||||
#define K_SYSCALL_GPIO_PIN_GET_CONFIG 7
|
||||
#define K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE 8
|
||||
#define K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW 9
|
||||
#define K_SYSCALL_GPIO_PORT_GET_DIRECTION 10
|
||||
#define K_SYSCALL_GPIO_PORT_GET_RAW 11
|
||||
#define K_SYSCALL_GPIO_PORT_SET_BITS_RAW 12
|
||||
#define K_SYSCALL_GPIO_PORT_SET_MASKED_RAW 13
|
||||
#define K_SYSCALL_GPIO_PORT_TOGGLE_BITS 14
|
||||
#define K_SYSCALL_K_BUSY_WAIT 15
|
||||
#define K_SYSCALL_K_CONDVAR_BROADCAST 16
|
||||
#define K_SYSCALL_K_CONDVAR_INIT 17
|
||||
#define K_SYSCALL_K_CONDVAR_SIGNAL 18
|
||||
#define K_SYSCALL_K_CONDVAR_WAIT 19
|
||||
#define K_SYSCALL_K_EVENT_CLEAR 20
|
||||
#define K_SYSCALL_K_EVENT_INIT 21
|
||||
#define K_SYSCALL_K_EVENT_POST 22
|
||||
#define K_SYSCALL_K_EVENT_SET 23
|
||||
#define K_SYSCALL_K_EVENT_SET_MASKED 24
|
||||
#define K_SYSCALL_K_EVENT_WAIT 25
|
||||
#define K_SYSCALL_K_EVENT_WAIT_ALL 26
|
||||
#define K_SYSCALL_K_EVENT_WAIT_ALL_SAFE 27
|
||||
#define K_SYSCALL_K_EVENT_WAIT_SAFE 28
|
||||
#define K_SYSCALL_K_FLOAT_DISABLE 29
|
||||
#define K_SYSCALL_K_FLOAT_ENABLE 30
|
||||
#define K_SYSCALL_K_FUTEX_WAIT 31
|
||||
#define K_SYSCALL_K_FUTEX_WAKE 32
|
||||
#define K_SYSCALL_K_IS_PREEMPT_THREAD 33
|
||||
#define K_SYSCALL_K_MSGQ_ALLOC_INIT 34
|
||||
#define K_SYSCALL_K_MSGQ_GET 35
|
||||
#define K_SYSCALL_K_MSGQ_GET_ATTRS 36
|
||||
#define K_SYSCALL_K_MSGQ_NUM_FREE_GET 37
|
||||
#define K_SYSCALL_K_MSGQ_NUM_USED_GET 38
|
||||
#define K_SYSCALL_K_MSGQ_PEEK 39
|
||||
#define K_SYSCALL_K_MSGQ_PEEK_AT 40
|
||||
#define K_SYSCALL_K_MSGQ_PURGE 41
|
||||
#define K_SYSCALL_K_MSGQ_PUT 42
|
||||
#define K_SYSCALL_K_MSGQ_PUT_FRONT 43
|
||||
#define K_SYSCALL_K_MUTEX_INIT 44
|
||||
#define K_SYSCALL_K_MUTEX_LOCK 45
|
||||
#define K_SYSCALL_K_MUTEX_UNLOCK 46
|
||||
#define K_SYSCALL_K_OBJECT_ACCESS_CHECK 47
|
||||
#define K_SYSCALL_K_OBJECT_ACCESS_GRANT 48
|
||||
#define K_SYSCALL_K_OBJECT_ALLOC 49
|
||||
#define K_SYSCALL_K_OBJECT_ALLOC_SIZE 50
|
||||
#define K_SYSCALL_K_OBJECT_RELEASE 51
|
||||
#define K_SYSCALL_K_PIPE_CLOSE 52
|
||||
#define K_SYSCALL_K_PIPE_INIT 53
|
||||
#define K_SYSCALL_K_PIPE_READ 54
|
||||
#define K_SYSCALL_K_PIPE_RESET 55
|
||||
#define K_SYSCALL_K_PIPE_WRITE 56
|
||||
#define K_SYSCALL_K_POLL 57
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_CHECK 58
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_INIT 59
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_RAISE 60
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_RESET 61
|
||||
#define K_SYSCALL_K_QUEUE_ALLOC_APPEND 62
|
||||
#define K_SYSCALL_K_QUEUE_ALLOC_PREPEND 63
|
||||
#define K_SYSCALL_K_QUEUE_CANCEL_WAIT 64
|
||||
#define K_SYSCALL_K_QUEUE_GET 65
|
||||
#define K_SYSCALL_K_QUEUE_INIT 66
|
||||
#define K_SYSCALL_K_QUEUE_IS_EMPTY 67
|
||||
#define K_SYSCALL_K_QUEUE_PEEK_HEAD 68
|
||||
#define K_SYSCALL_K_QUEUE_PEEK_TAIL 69
|
||||
#define K_SYSCALL_K_RESCHEDULE 70
|
||||
#define K_SYSCALL_K_SCHED_CURRENT_THREAD_QUERY 71
|
||||
#define K_SYSCALL_K_SEM_COUNT_GET 72
|
||||
#define K_SYSCALL_K_SEM_GIVE 73
|
||||
#define K_SYSCALL_K_SEM_INIT 74
|
||||
#define K_SYSCALL_K_SEM_RESET 75
|
||||
#define K_SYSCALL_K_SEM_TAKE 76
|
||||
#define K_SYSCALL_K_SLEEP 77
|
||||
#define K_SYSCALL_K_STACK_ALLOC_INIT 78
|
||||
#define K_SYSCALL_K_STACK_POP 79
|
||||
#define K_SYSCALL_K_STACK_PUSH 80
|
||||
#define K_SYSCALL_K_STR_OUT 81
|
||||
#define K_SYSCALL_K_THREAD_ABORT 82
|
||||
#define K_SYSCALL_K_THREAD_ABSOLUTE_DEADLINE_SET 83
|
||||
#define K_SYSCALL_K_THREAD_CREATE 84
|
||||
#define K_SYSCALL_K_THREAD_CUSTOM_DATA_GET 85
|
||||
#define K_SYSCALL_K_THREAD_CUSTOM_DATA_SET 86
|
||||
#define K_SYSCALL_K_THREAD_DEADLINE_SET 87
|
||||
#define K_SYSCALL_K_THREAD_JOIN 88
|
||||
#define K_SYSCALL_K_THREAD_NAME_COPY 89
|
||||
#define K_SYSCALL_K_THREAD_NAME_SET 90
|
||||
#define K_SYSCALL_K_THREAD_PRIORITY_GET 91
|
||||
#define K_SYSCALL_K_THREAD_PRIORITY_SET 92
|
||||
#define K_SYSCALL_K_THREAD_RESUME 93
|
||||
#define K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_GET 94
|
||||
#define K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_PCT_SET 95
|
||||
#define K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_SET 96
|
||||
#define K_SYSCALL_K_THREAD_STACK_ALLOC 97
|
||||
#define K_SYSCALL_K_THREAD_STACK_FREE 98
|
||||
#define K_SYSCALL_K_THREAD_STACK_SPACE_GET 99
|
||||
#define K_SYSCALL_K_THREAD_SUSPEND 100
|
||||
#define K_SYSCALL_K_THREAD_TIMEOUT_EXPIRES_TICKS 101
|
||||
#define K_SYSCALL_K_THREAD_TIMEOUT_REMAINING_TICKS 102
|
||||
#define K_SYSCALL_K_TIMER_EXPIRES_TICKS 103
|
||||
#define K_SYSCALL_K_TIMER_REMAINING_TICKS 104
|
||||
#define K_SYSCALL_K_TIMER_START 105
|
||||
#define K_SYSCALL_K_TIMER_STATUS_GET 106
|
||||
#define K_SYSCALL_K_TIMER_STATUS_SYNC 107
|
||||
#define K_SYSCALL_K_TIMER_STOP 108
|
||||
#define K_SYSCALL_K_TIMER_USER_DATA_GET 109
|
||||
#define K_SYSCALL_K_TIMER_USER_DATA_SET 110
|
||||
#define K_SYSCALL_K_UPTIME_TICKS 111
|
||||
#define K_SYSCALL_K_USLEEP 112
|
||||
#define K_SYSCALL_K_WAKEUP 113
|
||||
#define K_SYSCALL_K_YIELD 114
|
||||
#define K_SYSCALL_LOG_BUFFERED_CNT 115
|
||||
#define K_SYSCALL_LOG_FILTER_SET 116
|
||||
#define K_SYSCALL_LOG_FRONTEND_FILTER_SET 117
|
||||
#define K_SYSCALL_LOG_PANIC 118
|
||||
#define K_SYSCALL_LOG_PROCESS 119
|
||||
#define K_SYSCALL_SPI_RELEASE 120
|
||||
#define K_SYSCALL_SPI_TRANSCEIVE 121
|
||||
#define K_SYSCALL_SYS_CLOCK_GETRTOFFSET 122
|
||||
#define K_SYSCALL_SYS_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_GET 123
|
||||
#define K_SYSCALL_SYS_CLOCK_NANOSLEEP 124
|
||||
#define K_SYSCALL_SYS_CLOCK_SETTIME 125
|
||||
#define K_SYSCALL_UART_CONFIGURE 126
|
||||
#define K_SYSCALL_UART_CONFIG_GET 127
|
||||
#define K_SYSCALL_UART_DRV_CMD 128
|
||||
#define K_SYSCALL_UART_ERR_CHECK 129
|
||||
#define K_SYSCALL_UART_IRQ_ERR_DISABLE 130
|
||||
#define K_SYSCALL_UART_IRQ_ERR_ENABLE 131
|
||||
#define K_SYSCALL_UART_IRQ_IS_PENDING 132
|
||||
#define K_SYSCALL_UART_IRQ_RX_DISABLE 133
|
||||
#define K_SYSCALL_UART_IRQ_RX_ENABLE 134
|
||||
#define K_SYSCALL_UART_IRQ_TX_DISABLE 135
|
||||
#define K_SYSCALL_UART_IRQ_TX_ENABLE 136
|
||||
#define K_SYSCALL_UART_IRQ_UPDATE 137
|
||||
#define K_SYSCALL_UART_LINE_CTRL_GET 138
|
||||
#define K_SYSCALL_UART_LINE_CTRL_SET 139
|
||||
#define K_SYSCALL_UART_POLL_IN 140
|
||||
#define K_SYSCALL_UART_POLL_IN_U16 141
|
||||
#define K_SYSCALL_UART_POLL_OUT 142
|
||||
#define K_SYSCALL_UART_POLL_OUT_U16 143
|
||||
#define K_SYSCALL_UART_RX_DISABLE 144
|
||||
#define K_SYSCALL_UART_RX_ENABLE 145
|
||||
#define K_SYSCALL_UART_RX_ENABLE_U16 146
|
||||
#define K_SYSCALL_UART_TX 147
|
||||
#define K_SYSCALL_UART_TX_ABORT 148
|
||||
#define K_SYSCALL_UART_TX_U16 149
|
||||
#define K_SYSCALL_XTENSA_USER_FAULT 150
|
||||
#define K_SYSCALL_ZEPHYR_FPUTC 151
|
||||
#define K_SYSCALL_ZEPHYR_FWRITE 152
|
||||
#define K_SYSCALL_ZEPHYR_READ_STDIN 153
|
||||
#define K_SYSCALL_ZEPHYR_WRITE_STDOUT 154
|
||||
#define K_SYSCALL_Z_ERRNO 155
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0 156
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1 157
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2 158
|
||||
#define K_SYSCALL_Z_LOG_MSG_STATIC_CREATE 159
|
||||
#define K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK 160
|
||||
#define K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK 161
|
||||
#define K_SYSCALL_BAD 162
|
||||
#define K_SYSCALL_LIMIT 163
|
||||
|
||||
|
||||
/* Following syscalls are not used in image */
|
||||
#define K_SYSCALL_ADC_CHANNEL_SETUP 164
|
||||
#define K_SYSCALL_ADC_GET_DECODER 165
|
||||
#define K_SYSCALL_ADC_READ 166
|
||||
#define K_SYSCALL_ADC_READ_ASYNC 167
|
||||
#define K_SYSCALL_ATOMIC_ADD 168
|
||||
#define K_SYSCALL_ATOMIC_AND 169
|
||||
#define K_SYSCALL_ATOMIC_CAS 170
|
||||
#define K_SYSCALL_ATOMIC_NAND 171
|
||||
#define K_SYSCALL_ATOMIC_OR 172
|
||||
#define K_SYSCALL_ATOMIC_PTR_CAS 173
|
||||
#define K_SYSCALL_ATOMIC_PTR_SET 174
|
||||
#define K_SYSCALL_ATOMIC_SET 175
|
||||
#define K_SYSCALL_ATOMIC_SUB 176
|
||||
#define K_SYSCALL_ATOMIC_XOR 177
|
||||
#define K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET 178
|
||||
#define K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET 179
|
||||
#define K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET 180
|
||||
#define K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET 181
|
||||
#define K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET 182
|
||||
#define K_SYSCALL_AUXDISPLAY_CLEAR 183
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET 184
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET 185
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED 186
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET 187
|
||||
#define K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET 188
|
||||
#define K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND 189
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_OFF 190
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_ON 191
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET 192
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET 193
|
||||
#define K_SYSCALL_AUXDISPLAY_IS_BUSY 194
|
||||
#define K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED 195
|
||||
#define K_SYSCALL_AUXDISPLAY_WRITE 196
|
||||
#define K_SYSCALL_BBRAM_CHECK_INVALID 197
|
||||
#define K_SYSCALL_BBRAM_CHECK_POWER 198
|
||||
#define K_SYSCALL_BBRAM_CHECK_STANDBY_POWER 199
|
||||
#define K_SYSCALL_BBRAM_GET_SIZE 200
|
||||
#define K_SYSCALL_BBRAM_READ 201
|
||||
#define K_SYSCALL_BBRAM_WRITE 202
|
||||
#define K_SYSCALL_BC12_SET_RESULT_CB 203
|
||||
#define K_SYSCALL_BC12_SET_ROLE 204
|
||||
#define K_SYSCALL_BIOMETRIC_ATTR_GET 205
|
||||
#define K_SYSCALL_BIOMETRIC_ATTR_SET 206
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_ABORT 207
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_CAPTURE 208
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_FINALIZE 209
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_START 210
|
||||
#define K_SYSCALL_BIOMETRIC_GET_CAPABILITIES 211
|
||||
#define K_SYSCALL_BIOMETRIC_LED_CONTROL 212
|
||||
#define K_SYSCALL_BIOMETRIC_MATCH 213
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_DELETE 214
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_DELETE_ALL 215
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_LIST 216
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_READ 217
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_STORE 218
|
||||
#define K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ 219
|
||||
#define K_SYSCALL_CAN_CALC_TIMING 220
|
||||
#define K_SYSCALL_CAN_CALC_TIMING_DATA 221
|
||||
#define K_SYSCALL_CAN_GET_BITRATE_MAX 222
|
||||
#define K_SYSCALL_CAN_GET_BITRATE_MIN 223
|
||||
#define K_SYSCALL_CAN_GET_CAPABILITIES 224
|
||||
#define K_SYSCALL_CAN_GET_CORE_CLOCK 225
|
||||
#define K_SYSCALL_CAN_GET_MAX_FILTERS 226
|
||||
#define K_SYSCALL_CAN_GET_MODE 227
|
||||
#define K_SYSCALL_CAN_GET_STATE 228
|
||||
#define K_SYSCALL_CAN_GET_TIMING_DATA_MAX 229
|
||||
#define K_SYSCALL_CAN_GET_TIMING_DATA_MIN 230
|
||||
#define K_SYSCALL_CAN_GET_TIMING_MAX 231
|
||||
#define K_SYSCALL_CAN_GET_TIMING_MIN 232
|
||||
#define K_SYSCALL_CAN_GET_TRANSCEIVER 233
|
||||
#define K_SYSCALL_CAN_RECOVER 234
|
||||
#define K_SYSCALL_CAN_REMOVE_RX_FILTER 235
|
||||
#define K_SYSCALL_CAN_SEND 236
|
||||
#define K_SYSCALL_CAN_SET_BITRATE 237
|
||||
#define K_SYSCALL_CAN_SET_BITRATE_DATA 238
|
||||
#define K_SYSCALL_CAN_SET_MODE 239
|
||||
#define K_SYSCALL_CAN_SET_TIMING 240
|
||||
#define K_SYSCALL_CAN_SET_TIMING_DATA 241
|
||||
#define K_SYSCALL_CAN_START 242
|
||||
#define K_SYSCALL_CAN_STATS_GET_ACK_ERRORS 243
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS 244
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS 245
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT_ERRORS 246
|
||||
#define K_SYSCALL_CAN_STATS_GET_CRC_ERRORS 247
|
||||
#define K_SYSCALL_CAN_STATS_GET_FORM_ERRORS 248
|
||||
#define K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS 249
|
||||
#define K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS 250
|
||||
#define K_SYSCALL_CAN_STOP 251
|
||||
#define K_SYSCALL_CHARGER_CHARGE_ENABLE 252
|
||||
#define K_SYSCALL_CHARGER_GET_PROP 253
|
||||
#define K_SYSCALL_CHARGER_SET_PROP 254
|
||||
#define K_SYSCALL_COMPARATOR_GET_OUTPUT 255
|
||||
#define K_SYSCALL_COMPARATOR_SET_TRIGGER 256
|
||||
#define K_SYSCALL_COMPARATOR_TRIGGER_IS_PENDING 257
|
||||
#define K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM 258
|
||||
#define K_SYSCALL_COUNTER_GET_FREQUENCY 259
|
||||
#define K_SYSCALL_COUNTER_GET_FREQUENCY_64 260
|
||||
#define K_SYSCALL_COUNTER_GET_GUARD_PERIOD 261
|
||||
#define K_SYSCALL_COUNTER_GET_GUARD_PERIOD_64 262
|
||||
#define K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE 263
|
||||
#define K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE_64 264
|
||||
#define K_SYSCALL_COUNTER_GET_NUM_OF_CHANNELS 265
|
||||
#define K_SYSCALL_COUNTER_GET_PENDING_INT 266
|
||||
#define K_SYSCALL_COUNTER_GET_TOP_VALUE 267
|
||||
#define K_SYSCALL_COUNTER_GET_TOP_VALUE_64 268
|
||||
#define K_SYSCALL_COUNTER_GET_VALUE 269
|
||||
#define K_SYSCALL_COUNTER_GET_VALUE_64 270
|
||||
#define K_SYSCALL_COUNTER_IS_COUNTING_UP 271
|
||||
#define K_SYSCALL_COUNTER_NS_TO_TICKS 272
|
||||
#define K_SYSCALL_COUNTER_NS_TO_TICKS_64 273
|
||||
#define K_SYSCALL_COUNTER_RESET 274
|
||||
#define K_SYSCALL_COUNTER_SET_CHANNEL_ALARM 275
|
||||
#define K_SYSCALL_COUNTER_SET_CHANNEL_ALARM_64 276
|
||||
#define K_SYSCALL_COUNTER_SET_GUARD_PERIOD 277
|
||||
#define K_SYSCALL_COUNTER_SET_GUARD_PERIOD_64 278
|
||||
#define K_SYSCALL_COUNTER_SET_TOP_VALUE 279
|
||||
#define K_SYSCALL_COUNTER_SET_TOP_VALUE_64 280
|
||||
#define K_SYSCALL_COUNTER_SET_VALUE 281
|
||||
#define K_SYSCALL_COUNTER_SET_VALUE_64 282
|
||||
#define K_SYSCALL_COUNTER_START 283
|
||||
#define K_SYSCALL_COUNTER_STOP 284
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_NS 285
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_NS_64 286
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_US 287
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_US_64 288
|
||||
#define K_SYSCALL_COUNTER_US_TO_TICKS 289
|
||||
#define K_SYSCALL_COUNTER_US_TO_TICKS_64 290
|
||||
#define K_SYSCALL_CRC_BEGIN 291
|
||||
#define K_SYSCALL_CRC_FINISH 292
|
||||
#define K_SYSCALL_CRC_UPDATE 293
|
||||
#define K_SYSCALL_DAC_CHANNEL_SETUP 294
|
||||
#define K_SYSCALL_DAC_WRITE_VALUE 295
|
||||
#define K_SYSCALL_DAI_CONFIG_GET 296
|
||||
#define K_SYSCALL_DAI_CONFIG_SET 297
|
||||
#define K_SYSCALL_DAI_CONFIG_UPDATE 298
|
||||
#define K_SYSCALL_DAI_GET_PROPERTIES_COPY 299
|
||||
#define K_SYSCALL_DAI_PROBE 300
|
||||
#define K_SYSCALL_DAI_REMOVE 301
|
||||
#define K_SYSCALL_DAI_TRIGGER 302
|
||||
#define K_SYSCALL_DAI_TS_CONFIG 303
|
||||
#define K_SYSCALL_DAI_TS_GET 304
|
||||
#define K_SYSCALL_DAI_TS_START 305
|
||||
#define K_SYSCALL_DAI_TS_STOP 306
|
||||
#define K_SYSCALL_DEVMUX_SELECT_GET 307
|
||||
#define K_SYSCALL_DEVMUX_SELECT_SET 308
|
||||
#define K_SYSCALL_EEPROM_GET_SIZE 309
|
||||
#define K_SYSCALL_EEPROM_READ 310
|
||||
#define K_SYSCALL_EEPROM_WRITE 311
|
||||
#define K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF 312
|
||||
#define K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING 313
|
||||
#define K_SYSCALL_ENTROPY_GET_ENTROPY 314
|
||||
#define K_SYSCALL_ESPI_CONFIG 315
|
||||
#define K_SYSCALL_ESPI_FLASH_ERASE 316
|
||||
#define K_SYSCALL_ESPI_GET_CHANNEL_STATUS 317
|
||||
#define K_SYSCALL_ESPI_READ_FLASH 318
|
||||
#define K_SYSCALL_ESPI_READ_LPC_REQUEST 319
|
||||
#define K_SYSCALL_ESPI_READ_REQUEST 320
|
||||
#define K_SYSCALL_ESPI_RECEIVE_OOB 321
|
||||
#define K_SYSCALL_ESPI_RECEIVE_VWIRE 322
|
||||
#define K_SYSCALL_ESPI_SAF_ACTIVATE 323
|
||||
#define K_SYSCALL_ESPI_SAF_CONFIG 324
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_ERASE 325
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_READ 326
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS 327
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_WRITE 328
|
||||
#define K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS 329
|
||||
#define K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS 330
|
||||
#define K_SYSCALL_ESPI_SEND_OOB 331
|
||||
#define K_SYSCALL_ESPI_SEND_VWIRE 332
|
||||
#define K_SYSCALL_ESPI_WRITE_FLASH 333
|
||||
#define K_SYSCALL_ESPI_WRITE_LPC_REQUEST 334
|
||||
#define K_SYSCALL_ESPI_WRITE_REQUEST 335
|
||||
#define K_SYSCALL_FLASH_COPY 336
|
||||
#define K_SYSCALL_FLASH_ERASE 337
|
||||
#define K_SYSCALL_FLASH_EX_OP 338
|
||||
#define K_SYSCALL_FLASH_FILL 339
|
||||
#define K_SYSCALL_FLASH_FLATTEN 340
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_COUNT 341
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX 342
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS 343
|
||||
#define K_SYSCALL_FLASH_GET_PARAMETERS 344
|
||||
#define K_SYSCALL_FLASH_GET_SIZE 345
|
||||
#define K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE 346
|
||||
#define K_SYSCALL_FLASH_READ 347
|
||||
#define K_SYSCALL_FLASH_READ_JEDEC_ID 348
|
||||
#define K_SYSCALL_FLASH_SFDP_READ 349
|
||||
#define K_SYSCALL_FLASH_SIMULATOR_GET_MEMORY 350
|
||||
#define K_SYSCALL_FLASH_SIMULATOR_GET_PARAMS 351
|
||||
#define K_SYSCALL_FLASH_SIMULATOR_SET_CALLBACKS 352
|
||||
#define K_SYSCALL_FLASH_WRITE 353
|
||||
#define K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF 354
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP 355
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_PROP 356
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_PROPS 357
|
||||
#define K_SYSCALL_FUEL_GAUGE_SET_PROP 358
|
||||
#define K_SYSCALL_FUEL_GAUGE_SET_PROPS 359
|
||||
#define K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS 360
|
||||
#define K_SYSCALL_GNSS_GET_FIX_RATE 361
|
||||
#define K_SYSCALL_GNSS_GET_LATEST_TIMEPULSE 362
|
||||
#define K_SYSCALL_GNSS_GET_NAVIGATION_MODE 363
|
||||
#define K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS 364
|
||||
#define K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS 365
|
||||
#define K_SYSCALL_GNSS_SET_FIX_RATE 366
|
||||
#define K_SYSCALL_GNSS_SET_NAVIGATION_MODE 367
|
||||
#define K_SYSCALL_HAPTICS_START_OUTPUT 368
|
||||
#define K_SYSCALL_HAPTICS_STOP_OUTPUT 369
|
||||
#define K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE 370
|
||||
#define K_SYSCALL_HWINFO_GET_DEVICE_EUI64 371
|
||||
#define K_SYSCALL_HWINFO_GET_DEVICE_ID 372
|
||||
#define K_SYSCALL_HWINFO_GET_RESET_CAUSE 373
|
||||
#define K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE 374
|
||||
#define K_SYSCALL_I2C_CONFIGURE 375
|
||||
#define K_SYSCALL_I2C_GET_CONFIG 376
|
||||
#define K_SYSCALL_I2C_RECOVER_BUS 377
|
||||
#define K_SYSCALL_I2C_TARGET_DRIVER_REGISTER 378
|
||||
#define K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER 379
|
||||
#define K_SYSCALL_I2C_TRANSFER 380
|
||||
#define K_SYSCALL_I2S_BUF_READ 381
|
||||
#define K_SYSCALL_I2S_BUF_WRITE 382
|
||||
#define K_SYSCALL_I2S_CONFIGURE 383
|
||||
#define K_SYSCALL_I2S_TRIGGER 384
|
||||
#define K_SYSCALL_I3C_DO_CCC 385
|
||||
#define K_SYSCALL_I3C_TRANSFER 386
|
||||
#define K_SYSCALL_IPM_COMPLETE 387
|
||||
#define K_SYSCALL_IPM_MAX_DATA_SIZE_GET 388
|
||||
#define K_SYSCALL_IPM_MAX_ID_VAL_GET 389
|
||||
#define K_SYSCALL_IPM_SEND 390
|
||||
#define K_SYSCALL_IPM_SET_ENABLED 391
|
||||
#define K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS 392
|
||||
#define K_SYSCALL_IVSHMEM_GET_ID 393
|
||||
#define K_SYSCALL_IVSHMEM_GET_MAX_PEERS 394
|
||||
#define K_SYSCALL_IVSHMEM_GET_MEM 395
|
||||
#define K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION 396
|
||||
#define K_SYSCALL_IVSHMEM_GET_PROTOCOL 397
|
||||
#define K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION 398
|
||||
#define K_SYSCALL_IVSHMEM_GET_STATE 399
|
||||
#define K_SYSCALL_IVSHMEM_GET_VECTORS 400
|
||||
#define K_SYSCALL_IVSHMEM_INT_PEER 401
|
||||
#define K_SYSCALL_IVSHMEM_REGISTER_HANDLER 402
|
||||
#define K_SYSCALL_IVSHMEM_SET_STATE 403
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET 404
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET 405
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET 406
|
||||
#define K_SYSCALL_K_MEM_PAGING_STATS_GET 407
|
||||
#define K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET 408
|
||||
#define K_SYSCALL_LED_BLINK 409
|
||||
#define K_SYSCALL_LED_GET_INFO 410
|
||||
#define K_SYSCALL_LED_OFF 411
|
||||
#define K_SYSCALL_LED_ON 412
|
||||
#define K_SYSCALL_LED_SET_BRIGHTNESS 413
|
||||
#define K_SYSCALL_LED_SET_CHANNEL 414
|
||||
#define K_SYSCALL_LED_SET_COLOR 415
|
||||
#define K_SYSCALL_LED_WRITE_CHANNELS 416
|
||||
#define K_SYSCALL_LLEXT_GET_FN_TABLE 417
|
||||
#define K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT 418
|
||||
#define K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT 419
|
||||
#define K_SYSCALL_MBOX_MAX_CHANNELS_GET 420
|
||||
#define K_SYSCALL_MBOX_MTU_GET 421
|
||||
#define K_SYSCALL_MBOX_SEND 422
|
||||
#define K_SYSCALL_MBOX_SET_ENABLED 423
|
||||
#define K_SYSCALL_MDIO_READ 424
|
||||
#define K_SYSCALL_MDIO_READ_C45 425
|
||||
#define K_SYSCALL_MDIO_WRITE 426
|
||||
#define K_SYSCALL_MDIO_WRITE_C45 427
|
||||
#define K_SYSCALL_MSPI_CONFIG 428
|
||||
#define K_SYSCALL_MSPI_DEV_CONFIG 429
|
||||
#define K_SYSCALL_MSPI_GET_CHANNEL_STATUS 430
|
||||
#define K_SYSCALL_MSPI_SCRAMBLE_CONFIG 431
|
||||
#define K_SYSCALL_MSPI_TIMING_CONFIG 432
|
||||
#define K_SYSCALL_MSPI_TRANSCEIVE 433
|
||||
#define K_SYSCALL_MSPI_XIP_CONFIG 434
|
||||
#define K_SYSCALL_NET_ADDR_NTOP 435
|
||||
#define K_SYSCALL_NET_ADDR_PTON 436
|
||||
#define K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX 437
|
||||
#define K_SYSCALL_NET_IF_GET_BY_INDEX 438
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_ADD_BY_INDEX 439
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_LOOKUP_BY_INDEX 440
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX 441
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_GW_BY_INDEX 442
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_ADDR_BY_INDEX 443
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_INDEX 444
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_ADD_BY_INDEX 445
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_LOOKUP_BY_INDEX 446
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_RM_BY_INDEX 447
|
||||
#define K_SYSCALL_NET_SOCKET_SERVICE_REGISTER 448
|
||||
#define K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE 449
|
||||
#define K_SYSCALL_OPAMP_SET_GAIN 450
|
||||
#define K_SYSCALL_OTP_PROGRAM 451
|
||||
#define K_SYSCALL_OTP_READ 452
|
||||
#define K_SYSCALL_PECI_CONFIG 453
|
||||
#define K_SYSCALL_PECI_DISABLE 454
|
||||
#define K_SYSCALL_PECI_ENABLE 455
|
||||
#define K_SYSCALL_PECI_TRANSFER 456
|
||||
#define K_SYSCALL_PS2_CONFIG 457
|
||||
#define K_SYSCALL_PS2_DISABLE_CALLBACK 458
|
||||
#define K_SYSCALL_PS2_ENABLE_CALLBACK 459
|
||||
#define K_SYSCALL_PS2_READ 460
|
||||
#define K_SYSCALL_PS2_WRITE 461
|
||||
#define K_SYSCALL_PSI5_REGISTER_CALLBACK 462
|
||||
#define K_SYSCALL_PSI5_SEND 463
|
||||
#define K_SYSCALL_PSI5_START_SYNC 464
|
||||
#define K_SYSCALL_PSI5_STOP_SYNC 465
|
||||
#define K_SYSCALL_PTP_CLOCK_GET 466
|
||||
#define K_SYSCALL_PWM_CAPTURE_CYCLES 467
|
||||
#define K_SYSCALL_PWM_DISABLE_CAPTURE 468
|
||||
#define K_SYSCALL_PWM_DISABLE_DMA 469
|
||||
#define K_SYSCALL_PWM_ENABLE_CAPTURE 470
|
||||
#define K_SYSCALL_PWM_ENABLE_DMA 471
|
||||
#define K_SYSCALL_PWM_GET_CYCLES_PER_SEC 472
|
||||
#define K_SYSCALL_PWM_SET_CYCLES 473
|
||||
#define K_SYSCALL_RENESAS_ELC_DISABLE 474
|
||||
#define K_SYSCALL_RENESAS_ELC_ENABLE 475
|
||||
#define K_SYSCALL_RENESAS_ELC_LINK_BREAK 476
|
||||
#define K_SYSCALL_RENESAS_ELC_LINK_SET 477
|
||||
#define K_SYSCALL_RENESAS_ELC_SOFTWARE_EVENT_GENERATE 478
|
||||
#define K_SYSCALL_RENESAS_RA_CTSU_GROUP_CONFIGURE 479
|
||||
#define K_SYSCALL_RENESAS_RX_CTSU_GROUP_CONFIGURE 480
|
||||
#define K_SYSCALL_RESET_LINE_ASSERT 481
|
||||
#define K_SYSCALL_RESET_LINE_DEASSERT 482
|
||||
#define K_SYSCALL_RESET_LINE_TOGGLE 483
|
||||
#define K_SYSCALL_RESET_STATUS 484
|
||||
#define K_SYSCALL_RETAINED_MEM_CLEAR 485
|
||||
#define K_SYSCALL_RETAINED_MEM_READ 486
|
||||
#define K_SYSCALL_RETAINED_MEM_SIZE 487
|
||||
#define K_SYSCALL_RETAINED_MEM_WRITE 488
|
||||
#define K_SYSCALL_RTC_ALARM_GET_SUPPORTED_FIELDS 489
|
||||
#define K_SYSCALL_RTC_ALARM_GET_TIME 490
|
||||
#define K_SYSCALL_RTC_ALARM_IS_PENDING 491
|
||||
#define K_SYSCALL_RTC_ALARM_SET_TIME 492
|
||||
#define K_SYSCALL_RTC_GET_CALIBRATION 493
|
||||
#define K_SYSCALL_RTC_GET_TIME 494
|
||||
#define K_SYSCALL_RTC_SET_CALIBRATION 495
|
||||
#define K_SYSCALL_RTC_SET_TIME 496
|
||||
#define K_SYSCALL_RTIO_CQE_COPY_OUT 497
|
||||
#define K_SYSCALL_RTIO_CQE_GET_MEMPOOL_BUFFER 498
|
||||
#define K_SYSCALL_RTIO_POOL_ACQUIRE 499
|
||||
#define K_SYSCALL_RTIO_POOL_RELEASE 500
|
||||
#define K_SYSCALL_RTIO_RELEASE_BUFFER 501
|
||||
#define K_SYSCALL_RTIO_SQE_CANCEL 502
|
||||
#define K_SYSCALL_RTIO_SQE_COPY_IN_GET_HANDLES 503
|
||||
#define K_SYSCALL_RTIO_SQE_SIGNAL 504
|
||||
#define K_SYSCALL_RTIO_SUBMIT 505
|
||||
#define K_SYSCALL_SDHC_CARD_BUSY 506
|
||||
#define K_SYSCALL_SDHC_CARD_PRESENT 507
|
||||
#define K_SYSCALL_SDHC_DISABLE_INTERRUPT 508
|
||||
#define K_SYSCALL_SDHC_ENABLE_INTERRUPT 509
|
||||
#define K_SYSCALL_SDHC_EXECUTE_TUNING 510
|
||||
#define K_SYSCALL_SDHC_GET_HOST_PROPS 511
|
||||
#define K_SYSCALL_SDHC_HW_RESET 512
|
||||
#define K_SYSCALL_SDHC_REQUEST 513
|
||||
#define K_SYSCALL_SDHC_SET_IO 514
|
||||
#define K_SYSCALL_SENSOR_ATTR_GET 515
|
||||
#define K_SYSCALL_SENSOR_ATTR_SET 516
|
||||
#define K_SYSCALL_SENSOR_CHANNEL_GET 517
|
||||
#define K_SYSCALL_SENSOR_GET_DECODER 518
|
||||
#define K_SYSCALL_SENSOR_RECONFIGURE_READ_IODEV 519
|
||||
#define K_SYSCALL_SENSOR_SAMPLE_FETCH 520
|
||||
#define K_SYSCALL_SENSOR_SAMPLE_FETCH_CHAN 521
|
||||
#define K_SYSCALL_SENT_REGISTER_CALLBACK 522
|
||||
#define K_SYSCALL_SENT_START_LISTENING 523
|
||||
#define K_SYSCALL_SENT_STOP_LISTENING 524
|
||||
#define K_SYSCALL_SIP_SUPERVISORY_CALL 525
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_REQ 526
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_RES 527
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FORMAT_TRANS_ID 528
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FREE_ASYNC_MEMORY 529
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FUNC_ID_VALID 530
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_GET_ERROR_CODE 531
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_GET_TRANS_IDX 532
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_UPDATE_TRANS_ID 533
|
||||
#define K_SYSCALL_SMBUS_BLOCK_PCALL 534
|
||||
#define K_SYSCALL_SMBUS_BLOCK_READ 535
|
||||
#define K_SYSCALL_SMBUS_BLOCK_WRITE 536
|
||||
#define K_SYSCALL_SMBUS_BYTE_DATA_READ 537
|
||||
#define K_SYSCALL_SMBUS_BYTE_DATA_WRITE 538
|
||||
#define K_SYSCALL_SMBUS_BYTE_READ 539
|
||||
#define K_SYSCALL_SMBUS_BYTE_WRITE 540
|
||||
#define K_SYSCALL_SMBUS_CONFIGURE 541
|
||||
#define K_SYSCALL_SMBUS_GET_CONFIG 542
|
||||
#define K_SYSCALL_SMBUS_HOST_NOTIFY_REMOVE_CB 543
|
||||
#define K_SYSCALL_SMBUS_PCALL 544
|
||||
#define K_SYSCALL_SMBUS_QUICK 545
|
||||
#define K_SYSCALL_SMBUS_SMBALERT_REMOVE_CB 546
|
||||
#define K_SYSCALL_SMBUS_WORD_DATA_READ 547
|
||||
#define K_SYSCALL_SMBUS_WORD_DATA_WRITE 548
|
||||
#define K_SYSCALL_STEPPER_CTRL_CONFIGURE_RAMP 549
|
||||
#define K_SYSCALL_STEPPER_CTRL_GET_ACTUAL_POSITION 550
|
||||
#define K_SYSCALL_STEPPER_CTRL_IS_MOVING 551
|
||||
#define K_SYSCALL_STEPPER_CTRL_MOVE_BY 552
|
||||
#define K_SYSCALL_STEPPER_CTRL_MOVE_TO 553
|
||||
#define K_SYSCALL_STEPPER_CTRL_RUN 554
|
||||
#define K_SYSCALL_STEPPER_CTRL_SET_EVENT_CB 555
|
||||
#define K_SYSCALL_STEPPER_CTRL_SET_MICROSTEP_INTERVAL 556
|
||||
#define K_SYSCALL_STEPPER_CTRL_SET_REFERENCE_POSITION 557
|
||||
#define K_SYSCALL_STEPPER_CTRL_STOP 558
|
||||
#define K_SYSCALL_STEPPER_DISABLE 559
|
||||
#define K_SYSCALL_STEPPER_ENABLE 560
|
||||
#define K_SYSCALL_STEPPER_GET_MICRO_STEP_RES 561
|
||||
#define K_SYSCALL_STEPPER_SET_EVENT_CB 562
|
||||
#define K_SYSCALL_STEPPER_SET_MICRO_STEP_RES 563
|
||||
#define K_SYSCALL_SWDP_CONFIGURE 564
|
||||
#define K_SYSCALL_SWDP_GET_PINS 565
|
||||
#define K_SYSCALL_SWDP_INPUT_SEQUENCE 566
|
||||
#define K_SYSCALL_SWDP_OUTPUT_SEQUENCE 567
|
||||
#define K_SYSCALL_SWDP_PORT_OFF 568
|
||||
#define K_SYSCALL_SWDP_PORT_ON 569
|
||||
#define K_SYSCALL_SWDP_SET_CLOCK 570
|
||||
#define K_SYSCALL_SWDP_SET_PINS 571
|
||||
#define K_SYSCALL_SWDP_TRANSFER 572
|
||||
#define K_SYSCALL_SYSCON_GET_BASE 573
|
||||
#define K_SYSCALL_SYSCON_GET_SIZE 574
|
||||
#define K_SYSCALL_SYSCON_READ_REG 575
|
||||
#define K_SYSCALL_SYSCON_WRITE_REG 576
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE 577
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE 578
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE 579
|
||||
#define K_SYSCALL_SYS_CSRAND_GET 580
|
||||
#define K_SYSCALL_SYS_RAND_GET 581
|
||||
#define K_SYSCALL_TEE_CANCEL 582
|
||||
#define K_SYSCALL_TEE_CLOSE_SESSION 583
|
||||
#define K_SYSCALL_TEE_GET_VERSION 584
|
||||
#define K_SYSCALL_TEE_INVOKE_FUNC 585
|
||||
#define K_SYSCALL_TEE_OPEN_SESSION 586
|
||||
#define K_SYSCALL_TEE_SHM_ALLOC 587
|
||||
#define K_SYSCALL_TEE_SHM_FREE 588
|
||||
#define K_SYSCALL_TEE_SHM_REGISTER 589
|
||||
#define K_SYSCALL_TEE_SHM_UNREGISTER 590
|
||||
#define K_SYSCALL_TEE_SUPPL_RECV 591
|
||||
#define K_SYSCALL_TEE_SUPPL_SEND 592
|
||||
#define K_SYSCALL_TGPIO_PIN_CONFIG_EXT_TIMESTAMP 593
|
||||
#define K_SYSCALL_TGPIO_PIN_DISABLE 594
|
||||
#define K_SYSCALL_TGPIO_PIN_PERIODIC_OUTPUT 595
|
||||
#define K_SYSCALL_TGPIO_PIN_READ_TS_EC 596
|
||||
#define K_SYSCALL_TGPIO_PORT_GET_CYCLES_PER_SECOND 597
|
||||
#define K_SYSCALL_TGPIO_PORT_GET_TIME 598
|
||||
#define K_SYSCALL_UPDATEHUB_AUTOHANDLER 599
|
||||
#define K_SYSCALL_UPDATEHUB_CONFIRM 600
|
||||
#define K_SYSCALL_UPDATEHUB_PROBE 601
|
||||
#define K_SYSCALL_UPDATEHUB_REBOOT 602
|
||||
#define K_SYSCALL_UPDATEHUB_REPORT_ERROR 603
|
||||
#define K_SYSCALL_UPDATEHUB_UPDATE 604
|
||||
#define K_SYSCALL_USER_FAULT 605
|
||||
#define K_SYSCALL_W1_CHANGE_BUS_LOCK 606
|
||||
#define K_SYSCALL_W1_CONFIGURE 607
|
||||
#define K_SYSCALL_W1_GET_SLAVE_COUNT 608
|
||||
#define K_SYSCALL_W1_READ_BIT 609
|
||||
#define K_SYSCALL_W1_READ_BLOCK 610
|
||||
#define K_SYSCALL_W1_READ_BYTE 611
|
||||
#define K_SYSCALL_W1_RESET_BUS 612
|
||||
#define K_SYSCALL_W1_SEARCH_BUS 613
|
||||
#define K_SYSCALL_W1_WRITE_BIT 614
|
||||
#define K_SYSCALL_W1_WRITE_BLOCK 615
|
||||
#define K_SYSCALL_W1_WRITE_BYTE 616
|
||||
#define K_SYSCALL_WDT_DISABLE 617
|
||||
#define K_SYSCALL_WDT_FEED 618
|
||||
#define K_SYSCALL_WDT_SETUP 619
|
||||
#define K_SYSCALL_ZSOCK_ACCEPT 620
|
||||
#define K_SYSCALL_ZSOCK_BIND 621
|
||||
#define K_SYSCALL_ZSOCK_CLOSE 622
|
||||
#define K_SYSCALL_ZSOCK_CONNECT 623
|
||||
#define K_SYSCALL_ZSOCK_FCNTL_IMPL 624
|
||||
#define K_SYSCALL_ZSOCK_GETHOSTNAME 625
|
||||
#define K_SYSCALL_ZSOCK_GETPEERNAME 626
|
||||
#define K_SYSCALL_ZSOCK_GETSOCKNAME 627
|
||||
#define K_SYSCALL_ZSOCK_GETSOCKOPT 628
|
||||
#define K_SYSCALL_ZSOCK_GET_CONTEXT_OBJECT 629
|
||||
#define K_SYSCALL_ZSOCK_INET_PTON 630
|
||||
#define K_SYSCALL_ZSOCK_IOCTL_IMPL 631
|
||||
#define K_SYSCALL_ZSOCK_LISTEN 632
|
||||
#define K_SYSCALL_ZSOCK_RECVFROM 633
|
||||
#define K_SYSCALL_ZSOCK_RECVMSG 634
|
||||
#define K_SYSCALL_ZSOCK_SENDMSG 635
|
||||
#define K_SYSCALL_ZSOCK_SENDTO 636
|
||||
#define K_SYSCALL_ZSOCK_SETSOCKOPT 637
|
||||
#define K_SYSCALL_ZSOCK_SHUTDOWN 638
|
||||
#define K_SYSCALL_ZSOCK_SOCKET 639
|
||||
#define K_SYSCALL_ZSOCK_SOCKETPAIR 640
|
||||
#define K_SYSCALL_ZVFS_POLL 641
|
||||
#define K_SYSCALL_ZVFS_SELECT 642
|
||||
#define K_SYSCALL_Z_ZSOCK_GETADDRINFO_INTERNAL 643
|
||||
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#endif /* _ASMLANGUAGE */
|
||||
|
||||
#endif /* ZEPHYR_SYSCALL_LIST_H */
|
||||
34
build/zephyr/include/generated/xtensa_vectors.ld
Normal file
34
build/zephyr/include/generated/xtensa_vectors.ld
Normal file
@@ -0,0 +1,34 @@
|
||||
/* Automatically Generated Code - Do Not Edit */
|
||||
/* See arch/xtensa/core/gen_vector.py */
|
||||
|
||||
.z_xtensa_vectors : ALIGN(1024) {
|
||||
z_xtensa_vecbase = .;
|
||||
KEEP(*(.WindowVectors.text));
|
||||
KEEP(*(.Level2InterruptVector.literal));
|
||||
. = 0x180;
|
||||
KEEP(*(.Level2InterruptVector.text));
|
||||
KEEP(*(.Level3InterruptVector.literal));
|
||||
. = 0x1c0;
|
||||
KEEP(*(.Level3InterruptVector.text));
|
||||
KEEP(*(.Level4InterruptVector.literal));
|
||||
. = 0x200;
|
||||
KEEP(*(.Level4InterruptVector.text));
|
||||
KEEP(*(.Level5InterruptVector.literal));
|
||||
. = 0x240;
|
||||
KEEP(*(.Level5InterruptVector.text));
|
||||
KEEP(*(.DebugExceptionVector.literal));
|
||||
. = 0x280;
|
||||
KEEP(*(.DebugExceptionVector.text));
|
||||
KEEP(*(.NMIExceptionVector.literal));
|
||||
. = 0x2c0;
|
||||
KEEP(*(.NMIExceptionVector.text));
|
||||
KEEP(*(.KernelExceptionVector.literal));
|
||||
. = 0x300;
|
||||
KEEP(*(.KernelExceptionVector.text));
|
||||
KEEP(*(.UserExceptionVector.literal));
|
||||
. = 0x340;
|
||||
KEEP(*(.UserExceptionVector.text));
|
||||
KEEP(*(.DoubleExceptionVector.literal));
|
||||
. = 0x3c0;
|
||||
KEEP(*(.DoubleExceptionVector.text));
|
||||
}
|
||||
755
build/zephyr/include/generated/zephyr/autoconf.h
Normal file
755
build/zephyr/include/generated/zephyr/autoconf.h
Normal file
@@ -0,0 +1,755 @@
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_AES_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_BT_HCI_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_CLOCK_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_FLASH_CONTROLLER_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_GPIO_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_I2C_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_INTC_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_LCD_CAM_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_PINCTRL_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_PSRAM_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_SDHC_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_SHA_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_SPI_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_TIMER_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_TRNG_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_UART_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_USB_SERIAL_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_WATCHDOG_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_ESP32_WIFI_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ESPRESSIF_XTENSA_LX7_ENABLED 1
|
||||
#define CONFIG_DT_HAS_FIXED_PARTITIONS_ENABLED 1
|
||||
#define CONFIG_DT_HAS_GPIO_LEDS_ENABLED 1
|
||||
#define CONFIG_DT_HAS_MMIO_SRAM_ENABLED 1
|
||||
#define CONFIG_DT_HAS_SEEED_XIAO_GPIO_ENABLED 1
|
||||
#define CONFIG_DT_HAS_SEMTECH_SX1262_ENABLED 1
|
||||
#define CONFIG_DT_HAS_SOC_NV_FLASH_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ZEPHYR_MEMORY_REGION_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ZEPHYR_POWER_STATE_ENABLED 1
|
||||
#define CONFIG_MAIN_STACK_SIZE 2048
|
||||
#define CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE 1024
|
||||
#define CONFIG_SERIAL 1
|
||||
#define CONFIG_SPI 1
|
||||
#define CONFIG_UART_INTERRUPT_DRIVEN 1
|
||||
#define CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC 240000000
|
||||
#define CONFIG_FLASH_SIZE 8388608
|
||||
#define CONFIG_FLASH_BASE_ADDRESS 0x0
|
||||
#define CONFIG_MP_MAX_NUM_CPUS 1
|
||||
#define CONFIG_CLOCK_CONTROL 1
|
||||
#define CONFIG_IDLE_STACK_SIZE 1024
|
||||
#define CONFIG_ISR_STACK_SIZE 2048
|
||||
#define CONFIG_SYS_CLOCK_TICKS_PER_SEC 10000
|
||||
#define CONFIG_BUILD_OUTPUT_BIN 1
|
||||
#define CONFIG_ROM_START_OFFSET 0x0
|
||||
#define CONFIG_KERNEL_ENTRY "__start"
|
||||
#define CONFIG_HAS_FLASH_LOAD_OFFSET 1
|
||||
#define CONFIG_TICKLESS_KERNEL 1
|
||||
#define CONFIG_CLOCK_CONTROL_INIT_PRIORITY 30
|
||||
#define CONFIG_NUM_METAIRQ_PRIORITIES 0
|
||||
#define CONFIG_NUM_PREEMPT_PRIORITIES 15
|
||||
#define CONFIG_DYNAMIC_INTERRUPTS 1
|
||||
#define CONFIG_GEN_ISR_TABLES 1
|
||||
#define CONFIG_TIMESLICE_SIZE 20
|
||||
#define CONFIG_FLASH_LOAD_OFFSET 0x0
|
||||
#define CONFIG_SYS_CLOCK_EXISTS 1
|
||||
#define CONFIG_GPIO 1
|
||||
#define CONFIG_XTENSA_TIMER 1
|
||||
#define CONFIG_XTENSA_CCOUNT_HZ 240000000
|
||||
#define CONFIG_LOG 1
|
||||
#define CONFIG_ARCH_SW_ISR_TABLE_ALIGN 4
|
||||
#define CONFIG_LOG_DOMAIN_NAME ""
|
||||
#define CONFIG_LOG_PROCESS_THREAD_STACK_SIZE 1024
|
||||
#define CONFIG_UART_USE_RUNTIME_CONFIGURE 1
|
||||
#define CONFIG_CONSOLE 1
|
||||
#define CONFIG_COMMON_LIBC_MALLOC_ARENA_SIZE -1
|
||||
#define CONFIG_SOC_TOOLCHAIN_NAME "espressif_esp32s3"
|
||||
#define CONFIG_GEN_SW_ISR_TABLE 1
|
||||
#define CONFIG_GEN_IRQ_START_VECTOR 0
|
||||
#define CONFIG_SRAM_OFFSET 0x0
|
||||
#define CONFIG_XTENSA_TIMER_ID 0
|
||||
#define CONFIG_XTAL_FREQ_HZ 40000000
|
||||
#define CONFIG_SOC_FLASH_ESP32 1
|
||||
#define CONFIG_KERNEL_MEM_POOL 1
|
||||
#define CONFIG_MULTITHREADING 1
|
||||
#define CONFIG_LINKER_USE_RELAX 1
|
||||
#define CONFIG_ZEPHYR_ACPICA_MODULE 1
|
||||
#define CONFIG_ZEPHYR_CMSIS_MODULE 1
|
||||
#define CONFIG_ZEPHYR_CMSIS_DSP_MODULE 1
|
||||
#define CONFIG_ZEPHYR_CMSIS_NN_MODULE 1
|
||||
#define CONFIG_ZEPHYR_CMSIS_6_MODULE 1
|
||||
#define CONFIG_ZEPHYR_DHARA_MODULE 1
|
||||
#define CONFIG_ZEPHYR_FATFS_MODULE 1
|
||||
#define CONFIG_ZEPHYR_ADI_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_AFBR_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_AMBIQ_MODULE 1
|
||||
#define CONFIG_ZEPHYR_ATMEL_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_BOUFFALOLAB_MODULE 1
|
||||
#define CONFIG_ESP_HAL_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_ESP_HAL_LOG_LEVEL 3
|
||||
#define CONFIG_ESP_HAL_EARLY_LOG_LEVEL 3
|
||||
#define CONFIG_ESP_PLATFORM 1
|
||||
#define CONFIG_SOC_ADC_SUPPORTED 1
|
||||
#define CONFIG_SOC_UART_SUPPORTED 1
|
||||
#define CONFIG_SOC_MCPWM_SUPPORTED 1
|
||||
#define CONFIG_SOC_GPTIMER_SUPPORTED 1
|
||||
#define CONFIG_SOC_SDMMC_HOST_SUPPORTED 1
|
||||
#define CONFIG_SOC_BT_SUPPORTED 1
|
||||
#define CONFIG_SOC_PCNT_SUPPORTED 1
|
||||
#define CONFIG_SOC_PHY_SUPPORTED 1
|
||||
#define CONFIG_SOC_WIFI_SUPPORTED 1
|
||||
#define CONFIG_SOC_TWAI_SUPPORTED 1
|
||||
#define CONFIG_SOC_EFUSE_SUPPORTED 1
|
||||
#define CONFIG_SOC_ULP_SUPPORTED 1
|
||||
#define CONFIG_SOC_CCOMP_TIMER_SUPPORTED 1
|
||||
#define CONFIG_SOC_RTC_FAST_MEM_SUPPORTED 1
|
||||
#define CONFIG_SOC_RTC_SLOW_MEM_SUPPORTED 1
|
||||
#define CONFIG_SOC_RTC_MEM_SUPPORTED 1
|
||||
#define CONFIG_SOC_RTC_TIMER_V1_SUPPORTED 1
|
||||
#define CONFIG_SOC_I2S_SUPPORTED 1
|
||||
#define CONFIG_SOC_LCD_I80_SUPPORTED 1
|
||||
#define CONFIG_SOC_RMT_SUPPORTED 1
|
||||
#define CONFIG_SOC_SDM_SUPPORTED 1
|
||||
#define CONFIG_SOC_GPSPI_SUPPORTED 1
|
||||
#define CONFIG_SOC_LEDC_SUPPORTED 1
|
||||
#define CONFIG_SOC_I2C_SUPPORTED 1
|
||||
#define CONFIG_SOC_SUPPORT_COEXISTENCE 1
|
||||
#define CONFIG_SOC_AES_SUPPORTED 1
|
||||
#define CONFIG_SOC_MPI_SUPPORTED 1
|
||||
#define CONFIG_SOC_SHA_SUPPORTED 1
|
||||
#define CONFIG_SOC_FLASH_ENC_SUPPORTED 1
|
||||
#define CONFIG_SOC_SECURE_BOOT_SUPPORTED 1
|
||||
#define CONFIG_SOC_TOUCH_SENSOR_SUPPORTED 1
|
||||
#define CONFIG_SOC_BOD_SUPPORTED 1
|
||||
#define CONFIG_SOC_ULP_FSM_SUPPORTED 1
|
||||
#define CONFIG_SOC_CLK_TREE_SUPPORTED 1
|
||||
#define CONFIG_SOC_MPU_SUPPORTED 1
|
||||
#define CONFIG_SOC_WDT_SUPPORTED 1
|
||||
#define CONFIG_SOC_SPI_FLASH_SUPPORTED 1
|
||||
#define CONFIG_SOC_RNG_SUPPORTED 1
|
||||
#define CONFIG_SOC_LIGHT_SLEEP_SUPPORTED 1
|
||||
#define CONFIG_SOC_DEEP_SLEEP_SUPPORTED 1
|
||||
#define CONFIG_SOC_LP_PERIPH_SHARE_INTERRUPT 1
|
||||
#define CONFIG_SOC_PM_SUPPORTED 1
|
||||
#define CONFIG_SOC_SPI_EXTERNAL_NOR_FLASH_SUPPORTED 1
|
||||
#define CONFIG_SOC_XTAL_SUPPORT_40M 1
|
||||
#define CONFIG_SOC_ADC_RTC_CTRL_SUPPORTED 1
|
||||
#define CONFIG_SOC_ADC_DIG_CTRL_SUPPORTED 1
|
||||
#define CONFIG_SOC_ADC_DMA_SUPPORTED 1
|
||||
#define CONFIG_SOC_ADC_PERIPH_NUM 2
|
||||
#define CONFIG_SOC_ADC_MAX_CHANNEL_NUM 10
|
||||
#define CONFIG_SOC_ADC_ATTEN_NUM 4
|
||||
#define CONFIG_SOC_ADC_DIGI_CONTROLLER_NUM 2
|
||||
#define CONFIG_SOC_ADC_PATT_LEN_MAX 24
|
||||
#define CONFIG_SOC_ADC_DIGI_MIN_BITWIDTH 12
|
||||
#define CONFIG_SOC_ADC_DIGI_MAX_BITWIDTH 12
|
||||
#define CONFIG_SOC_ADC_DIGI_RESULT_BYTES 4
|
||||
#define CONFIG_SOC_ADC_DIGI_DATA_BYTES_PER_CONV 4
|
||||
#define CONFIG_SOC_ADC_DIGI_MONITOR_NUM 2
|
||||
#define CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_HIGH 83333
|
||||
#define CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_LOW 611
|
||||
#define CONFIG_SOC_ADC_RTC_MIN_BITWIDTH 12
|
||||
#define CONFIG_SOC_ADC_RTC_MAX_BITWIDTH 12
|
||||
#define CONFIG_SOC_ADC_SHARED_POWER 1
|
||||
#define CONFIG_SOC_BROWNOUT_RESET_SUPPORTED 1
|
||||
#define CONFIG_SOC_CPU_CORES_NUM 2
|
||||
#define CONFIG_SOC_CPU_INTR_NUM 32
|
||||
#define CONFIG_SOC_CPU_HAS_FPU 1
|
||||
#define CONFIG_SOC_HP_CPU_HAS_MULTIPLE_CORES 1
|
||||
#define CONFIG_SOC_CPU_BREAKPOINTS_NUM 2
|
||||
#define CONFIG_SOC_CPU_WATCHPOINTS_NUM 2
|
||||
#define CONFIG_SOC_CPU_WATCHPOINT_MAX_REGION_SIZE 0x40
|
||||
#define CONFIG_SOC_GPIO_PORT 1
|
||||
#define CONFIG_SOC_GPIO_PIN_COUNT 49
|
||||
#define CONFIG_SOC_GPIO_VALID_GPIO_MASK 0x1FFFFFFFFFFFF
|
||||
#define CONFIG_SOC_GPIO_IN_RANGE_MAX 48
|
||||
#define CONFIG_SOC_GPIO_OUT_RANGE_MAX 48
|
||||
#define CONFIG_SOC_GPIO_VALID_DIGITAL_IO_PAD_MASK 0x0001FFFFFC000000
|
||||
#define CONFIG_SOC_GPIO_CLOCKOUT_BY_IO_MUX 1
|
||||
#define CONFIG_SOC_GPIO_CLOCKOUT_CHANNEL_NUM 3
|
||||
#define CONFIG_SOC_I2C_NUM 2
|
||||
#define CONFIG_SOC_HP_I2C_NUM 2
|
||||
#define CONFIG_SOC_I2C_SUPPORT_10BIT_ADDR 1
|
||||
#define CONFIG_SOC_I2C_SUPPORT_SLAVE 1
|
||||
#define CONFIG_SOC_I2S_SUPPORTS_PDM 1
|
||||
#define CONFIG_SOC_I2S_SUPPORTS_PDM_TX 1
|
||||
#define CONFIG_SOC_I2S_SUPPORTS_PCM2PDM 1
|
||||
#define CONFIG_SOC_I2S_SUPPORTS_PDM_RX 1
|
||||
#define CONFIG_SOC_I2S_SUPPORTS_PDM2PCM 1
|
||||
#define CONFIG_SOC_I2S_PDM_MAX_TX_LINES 2
|
||||
#define CONFIG_SOC_I2S_PDM_MAX_RX_LINES 4
|
||||
#define CONFIG_SOC_LEDC_SUPPORT_APB_CLOCK 1
|
||||
#define CONFIG_SOC_LEDC_TIMER_NUM 4
|
||||
#define CONFIG_SOC_LEDC_CHANNEL_NUM 8
|
||||
#define CONFIG_SOC_LEDC_TIMER_BIT_WIDTH 14
|
||||
#define CONFIG_SOC_MMU_PERIPH_NUM 1
|
||||
#define CONFIG_SOC_MMU_LINEAR_ADDRESS_REGION_NUM 1
|
||||
#define CONFIG_SOC_MPU_MIN_REGION_SIZE 0x20000000
|
||||
#define CONFIG_SOC_MPU_REGIONS_MAX_NUM 8
|
||||
#define CONFIG_SOC_RMT_MEM_WORDS_PER_CHANNEL 48
|
||||
#define CONFIG_SOC_RTCIO_PIN_COUNT 22
|
||||
#define CONFIG_SOC_RTCIO_INPUT_OUTPUT_SUPPORTED 1
|
||||
#define CONFIG_SOC_RTCIO_HOLD_SUPPORTED 1
|
||||
#define CONFIG_SOC_RTCIO_WAKE_SUPPORTED 1
|
||||
#define CONFIG_SOC_SPI_PERIPH_NUM 3
|
||||
#define CONFIG_SOC_SPI_MAXIMUM_BUFFER_SIZE 64
|
||||
#define CONFIG_SOC_LP_TIMER_BIT_WIDTH_LO 32
|
||||
#define CONFIG_SOC_LP_TIMER_BIT_WIDTH_HI 16
|
||||
#define CONFIG_SOC_TOUCH_SENSOR_VERSION 2
|
||||
#define CONFIG_SOC_TOUCH_MIN_CHAN_ID 1
|
||||
#define CONFIG_SOC_TOUCH_MAX_CHAN_ID 14
|
||||
#define CONFIG_SOC_TOUCH_SUPPORT_SLEEP_WAKEUP 1
|
||||
#define CONFIG_SOC_TOUCH_SAMPLE_CFG_NUM 1
|
||||
#define CONFIG_SOC_TWAI_CONTROLLER_NUM 1
|
||||
#define CONFIG_SOC_TWAI_MASK_FILTER_NUM 1
|
||||
#define CONFIG_SOC_UART_NUM 3
|
||||
#define CONFIG_SOC_UART_HP_NUM 3
|
||||
#define CONFIG_SOC_UART_SUPPORT_APB_CLK 1
|
||||
#define CONFIG_SOC_UART_FIFO_LEN 128
|
||||
#define CONFIG_SOC_UART_BITRATE_MAX 5000000
|
||||
#define CONFIG_SOC_UART_WAKEUP_SUPPORT_ACTIVE_THRESH_MODE 1
|
||||
#define CONFIG_SOC_SPIRAM_SUPPORTED 1
|
||||
#define CONFIG_SOC_SPI_MEM_SUPPORT_CONFIG_GPIO_BY_EFUSE 1
|
||||
#define CONFIG_SOC_SHA_SUPPORT_SHA1 1
|
||||
#define CONFIG_SOC_SHA_SUPPORT_SHA256 1
|
||||
#define CONFIG_SOC_SHA_SUPPORT_SHA384 1
|
||||
#define CONFIG_SOC_SHA_SUPPORT_SHA512 1
|
||||
#define CONFIG_SOC_MPI_MEM_BLOCKS_NUM 4
|
||||
#define CONFIG_SOC_MPI_OPERATIONS_NUM 3
|
||||
#define CONFIG_SOC_RSA_MAX_BIT_LEN 4096
|
||||
#define CONFIG_SOC_AES_SUPPORT_AES_128 1
|
||||
#define CONFIG_SOC_AES_SUPPORT_AES_256 1
|
||||
#define CONFIG_SOC_EFUSE_SECURE_BOOT_KEY_DIGESTS 3
|
||||
#define CONFIG_SOC_FLASH_ENCRYPTED_XTS_AES_BLOCK_MAX 64
|
||||
#define CONFIG_SOC_PHY_DIG_REGS_MEM_SIZE 21
|
||||
#define CONFIG_SOC_PM_SUPPORT_EXT0_WAKEUP 1
|
||||
#define CONFIG_SOC_PM_SUPPORT_EXT1_WAKEUP 1
|
||||
#define CONFIG_SOC_PM_SUPPORT_EXT_WAKEUP 1
|
||||
#define CONFIG_SOC_PM_SUPPORT_TOUCH_SENSOR_WAKEUP 1
|
||||
#define CONFIG_SOC_PM_SUPPORT_RTC_PERIPH_PD 1
|
||||
#define CONFIG_SOC_PM_SUPPORT_RC_FAST_PD 1
|
||||
#define CONFIG_SOC_PM_SUPPORT_VDDSDIO_PD 1
|
||||
#define CONFIG_SOC_PM_SUPPORT_MODEM_PD 1
|
||||
#define CONFIG_SOC_CONFIGURABLE_VDDSDIO_SUPPORTED 1
|
||||
#define CONFIG_SOC_PM_MODEM_PD_BY_SW 1
|
||||
#define CONFIG_SOC_CLK_RC_FAST_D256_SUPPORTED 1
|
||||
#define CONFIG_SOC_RTC_SLOW_CLK_SUPPORT_RC_FAST_D256 1
|
||||
#define CONFIG_SOC_CLK_RC_FAST_SUPPORT_CALIBRATION 1
|
||||
#define CONFIG_SOC_CLK_XTAL32K_SUPPORTED 1
|
||||
#define CONFIG_SOC_SDMMC_NUM_SLOTS 2
|
||||
#define CONFIG_SOC_SDMMC_DATA_WIDTH_MAX 8
|
||||
#define CONFIG_SOC_WIFI_WAPI_SUPPORT 1
|
||||
#define CONFIG_SOC_WIFI_CSI_SUPPORT 1
|
||||
#define CONFIG_SOC_WIFI_MESH_SUPPORT 1
|
||||
#define CONFIG_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW 1
|
||||
#define CONFIG_SOC_BLE_SUPPORTED 1
|
||||
#define CONFIG_SOC_BLE_MESH_SUPPORTED 1
|
||||
#define CONFIG_SOC_BLE_DEVICE_PRIVACY_SUPPORTED 1
|
||||
#define CONFIG_SOC_BLUFI_SUPPORTED 1
|
||||
#define CONFIG_SOC_ULP_HAS_ADC 1
|
||||
#define CONFIG_SOC_PHY_COMBO_MODULE 1
|
||||
#define CONFIG_SOC_DEDICATED_GPIO_SUPPORTED 1
|
||||
#define CONFIG_SOC_SUPPORTS_SECURE_DL_MODE 1
|
||||
#define CONFIG_SOC_RISCV_COPROC_SUPPORTED 1
|
||||
#define CONFIG_SOC_USB_OTG_SUPPORTED 1
|
||||
#define CONFIG_SOC_ASYNC_MEMCPY_SUPPORTED 1
|
||||
#define CONFIG_SOC_EFUSE_KEY_PURPOSE_FIELD 1
|
||||
#define CONFIG_SOC_TEMP_SENSOR_SUPPORTED 1
|
||||
#define CONFIG_SOC_CACHE_SUPPORT_WRAP 1
|
||||
#define CONFIG_SOC_PSRAM_DMA_CAPABLE 1
|
||||
#define CONFIG_SOC_XT_WDT_SUPPORTED 1
|
||||
#define CONFIG_SOC_SYSTIMER_SUPPORTED 1
|
||||
#define CONFIG_SOC_HMAC_SUPPORTED 1
|
||||
#define CONFIG_SOC_DIG_SIGN_SUPPORTED 1
|
||||
#define CONFIG_SOC_MEMPROT_SUPPORTED 1
|
||||
#define CONFIG_SOC_ADC_ARBITER_SUPPORTED 1
|
||||
#define CONFIG_SOC_ADC_DIG_IIR_FILTER_SUPPORTED 1
|
||||
#define CONFIG_SOC_ADC_MONITOR_SUPPORTED 1
|
||||
#define CONFIG_SOC_ADC_DIGI_IIR_FILTER_NUM 2
|
||||
#define CONFIG_SOC_ADC_CALIBRATION_V1_SUPPORTED 1
|
||||
#define CONFIG_SOC_ADC_SELF_HW_CALI_SUPPORTED 1
|
||||
#define CONFIG_SOC_CACHE_WRITEBACK_SUPPORTED 1
|
||||
#define CONFIG_SOC_DS_SIGNATURE_MAX_BIT_LEN 4096
|
||||
#define CONFIG_SOC_DS_KEY_PARAM_MD_IV_LENGTH 16
|
||||
#define CONFIG_SOC_DS_KEY_CHECK_MAX_WAIT_US 1100
|
||||
#define CONFIG_SOC_GPIO_SUPPORT_PIN_GLITCH_FILTER 1
|
||||
#define CONFIG_SOC_GPIO_SUPPORT_FORCE_HOLD 1
|
||||
#define CONFIG_SOC_I2C_SLAVE_CAN_GET_STRETCH_CAUSE 1
|
||||
#define CONFIG_SOC_LEDC_SUPPORT_XTAL_CLOCK 1
|
||||
#define CONFIG_SOC_LEDC_SUPPORT_FADE_STOP 1
|
||||
#define CONFIG_SOC_RMT_SUPPORT_TX_LOOP_COUNT 1
|
||||
#define CONFIG_SOC_LP_IO_CLOCK_IS_INDEPENDENT 1
|
||||
#define CONFIG_SOC_SPI_SUPPORT_SLAVE_HD_VER2 1
|
||||
#define CONFIG_SOC_SPI_SUPPORT_OCT 1
|
||||
#define CONFIG_SOC_MEMSPI_SUPPORT_CONTROL_DUMMY_OUT 1
|
||||
#define CONFIG_SOC_MEMSPI_IS_INDEPENDENT 1
|
||||
#define CONFIG_SOC_TOUCH_SUPPORT_BENCHMARK 1
|
||||
#define CONFIG_SOC_TOUCH_SUPPORT_WATERPROOF 1
|
||||
#define CONFIG_SOC_TOUCH_SUPPORT_PROX_SENSING 1
|
||||
#define CONFIG_SOC_TOUCH_SUPPORT_DENOISE_CHAN 1
|
||||
#define CONFIG_SOC_TOUCH_PROXIMITY_CHANNEL_NUM 3
|
||||
#define CONFIG_SOC_UART_SUPPORT_WAKEUP_INT 1
|
||||
#define CONFIG_SOC_SPIRAM_XIP_SUPPORTED 1
|
||||
#define CONFIG_SOC_USB_OTG_PERIPH_NUM 1
|
||||
#define CONFIG_SOC_SHA_DMA_MAX_BUFFER_SIZE 3968
|
||||
#define CONFIG_SOC_SHA_SUPPORT_DMA 1
|
||||
#define CONFIG_SOC_SHA_SUPPORT_RESUME 1
|
||||
#define CONFIG_SOC_SHA_SUPPORT_SHA224 1
|
||||
#define CONFIG_SOC_SHA_SUPPORT_SHA512_224 1
|
||||
#define CONFIG_SOC_SHA_SUPPORT_SHA512_256 1
|
||||
#define CONFIG_SOC_SHA_SUPPORT_SHA512_T 1
|
||||
#define CONFIG_SOC_AES_SUPPORT_DMA 1
|
||||
#define CONFIG_SOC_EFUSE_DIS_DOWNLOAD_ICACHE 1
|
||||
#define CONFIG_SOC_EFUSE_DIS_DOWNLOAD_DCACHE 1
|
||||
#define CONFIG_SOC_EFUSE_HARD_DIS_JTAG 1
|
||||
#define CONFIG_SOC_EFUSE_SOFT_DIS_JTAG 1
|
||||
#define CONFIG_SOC_EFUSE_DIS_ICACHE 1
|
||||
#define CONFIG_SOC_EFUSE_XTS_AES_KEY_128 1
|
||||
#define CONFIG_SOC_EFUSE_XTS_AES_KEY_256 1
|
||||
#define CONFIG_SOC_SECURE_BOOT_V2_RSA 1
|
||||
#define CONFIG_SOC_EFUSE_REVOKE_BOOT_KEY_DIGESTS 1
|
||||
#define CONFIG_SOC_SUPPORT_SECURE_BOOT_REVOKE_KEY 1
|
||||
#define CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES 1
|
||||
#define CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_OPTIONS 1
|
||||
#define CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_128 1
|
||||
#define CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_256 1
|
||||
#define CONFIG_SOC_MEMPROT_CPU_PREFETCH_PAD_SIZE 16
|
||||
#define CONFIG_SOC_MEMPROT_MEM_ALIGN_SIZE 256
|
||||
#define CONFIG_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH 12
|
||||
#define CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_WAIT_IDLE 1
|
||||
#define CONFIG_SOC_SPI_MEM_SUPPORT_SW_SUSPEND 1
|
||||
#define CONFIG_SOC_SPI_MEM_SUPPORT_WRAP 1
|
||||
#define CONFIG_SOC_PM_SUPPORT_WIFI_WAKEUP 1
|
||||
#define CONFIG_SOC_COEX_HW_PTI 1
|
||||
#define CONFIG_SOC_EXTERNAL_COEX_LEADER_TX_LINE 1
|
||||
#define CONFIG_SOC_TEMPERATURE_SENSOR_SUPPORT_FAST_RC 1
|
||||
#define CONFIG_SOC_WIFI_HW_TSF 1
|
||||
#define CONFIG_SOC_WIFI_FTM_SUPPORT 1
|
||||
#define CONFIG_SOC_GDMA_SUPPORTED 1
|
||||
#define CONFIG_SOC_UHCI_SUPPORTED 1
|
||||
#define CONFIG_SOC_AHB_GDMA_SUPPORTED 1
|
||||
#define CONFIG_SOC_LCDCAM_CAM_SUPPORTED 1
|
||||
#define CONFIG_SOC_LCDCAM_I80_LCD_SUPPORTED 1
|
||||
#define CONFIG_SOC_LCDCAM_RGB_LCD_SUPPORTED 1
|
||||
#define CONFIG_SOC_LCD_RGB_SUPPORTED 1
|
||||
#define CONFIG_SOC_USB_SERIAL_JTAG_SUPPORTED 1
|
||||
#define CONFIG_SOC_SIMD_INSTRUCTION_SUPPORTED 1
|
||||
#define CONFIG_SOC_APPCPU_HAS_CLOCK_GATING_BUG 1
|
||||
#define CONFIG_SOC_APB_BACKUP_DMA 1
|
||||
#define CONFIG_SOC_CACHE_FREEZE_SUPPORTED 1
|
||||
#define CONFIG_SOC_CACHE_ACS_INVALID_STATE_ON_PANIC 1
|
||||
#define CONFIG_SOC_SIMD_PREFERRED_DATA_ALIGNMENT 16
|
||||
#define CONFIG_SOC_AHB_GDMA_VERSION 1
|
||||
#define CONFIG_SOC_I2C_SUPPORT_XTAL 1
|
||||
#define CONFIG_SOC_I2C_SUPPORT_RTC 1
|
||||
#define CONFIG_SOC_I2C_SLAVE_SUPPORT_BROADCAST 1
|
||||
#define CONFIG_SOC_I2S_HW_VERSION_2 1
|
||||
#define CONFIG_SOC_I2S_SUPPORTS_PCM 1
|
||||
#define CONFIG_SOC_I2S_SUPPORTS_TDM 1
|
||||
#define CONFIG_SOC_MCPWM_SWSYNC_CAN_PROPAGATE 1
|
||||
#define CONFIG_SOC_RMT_SUPPORT_RX_PINGPONG 1
|
||||
#define CONFIG_SOC_RMT_SUPPORT_TX_LOOP_AUTO_STOP 1
|
||||
#define CONFIG_SOC_RMT_SUPPORT_DMA 1
|
||||
#define CONFIG_SOC_RTC_CNTL_CPU_PD_DMA_BUS_WIDTH 128
|
||||
#define CONFIG_SOC_RTC_CNTL_CPU_PD_REG_FILE_NUM 549
|
||||
#define CONFIG_SOC_RTC_CNTL_TAGMEM_PD_DMA_BUS_WIDTH 128
|
||||
#define CONFIG_SOC_UART_SUPPORT_RTC_CLK 1
|
||||
#define CONFIG_SOC_UART_SUPPORT_XTAL_CLK 1
|
||||
#define CONFIG_SOC_UHCI_NUM 1
|
||||
#define CONFIG_SOC_SHA_GDMA 1
|
||||
#define CONFIG_SOC_AES_GDMA 1
|
||||
#define CONFIG_SOC_PM_SUPPORT_BT_WAKEUP 1
|
||||
#define CONFIG_SOC_PM_SUPPORT_CPU_PD 1
|
||||
#define CONFIG_SOC_PM_SUPPORT_TAGMEM_PD 1
|
||||
#define CONFIG_SOC_PM_SUPPORT_MAC_BB_PD 1
|
||||
#define CONFIG_SOC_PM_SUPPORT_DEEPSLEEP_CHECK_STUB_ONLY 1
|
||||
#define CONFIG_SOC_PM_CPU_RETENTION_BY_RTCCNTL 1
|
||||
#define CONFIG_SOC_PM_MODEM_RETENTION_BY_BACKUPDMA 1
|
||||
#define CONFIG_SOC_CLK_LP_FAST_SUPPORT_XTAL_D2 1
|
||||
#define CONFIG_SOC_EFUSE_DIS_USB_JTAG 1
|
||||
#define CONFIG_SOC_EFUSE_DIS_DIRECT_BOOT 1
|
||||
#define CONFIG_SOC_EFUSE_BLOCK9_KEY_PURPOSE_QUIRK 1
|
||||
#define CONFIG_SOC_MAC_BB_PD_MEM_SIZE 192
|
||||
#define CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_SUSPEND 1
|
||||
#define CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_RESUME 1
|
||||
#define CONFIG_SOC_SPI_MEM_SUPPORT_FLASH_OPI_MODE 1
|
||||
#define CONFIG_SOC_SPI_MEM_SUPPORT_TIMING_TUNING 1
|
||||
#define CONFIG_SOC_MEMSPI_TIMING_TUNING_BY_MSPI_DELAY 1
|
||||
#define CONFIG_SOC_MEMSPI_CORE_CLK_SHARED_WITH_PSRAM 1
|
||||
#define CONFIG_SOC_SPI_MEM_SUPPORT_CACHE_32BIT_ADDR_MAP 1
|
||||
#define CONFIG_SOC_SPI_MEM_FLASH_SUPPORT_HPM 1
|
||||
#define CONFIG_SOC_SDMMC_USE_GPIO_MATRIX 1
|
||||
#define CONFIG_SOC_SDMMC_DELAY_PHASE_NUM 4
|
||||
#define CONFIG_SOC_WIFI_GCMP_SUPPORT 1
|
||||
#define CONFIG_SOC_WIFI_TXOP_SUPPORT 1
|
||||
#define CONFIG_SOC_WIFI_PHY_NEEDS_USB_WORKAROUND 1
|
||||
#define CONFIG_SOC_BLE_50_SUPPORTED 1
|
||||
#define CONFIG_SOC_LCDCAM_CAM_SUPPORT_RGB_YUV_CONV 1
|
||||
#define CONFIG_XTAL_FREQ 40
|
||||
#define CONFIG_XTAL_FREQ_40 1
|
||||
#define CONFIG_BOOTLOADER_OFFSET_IN_FLASH 0x0
|
||||
#define CONFIG_BOOTLOADER_CPU_CLK_FREQ_MHZ 80
|
||||
#define CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ 240
|
||||
#define CONFIG_ESP_CLK_FREQ_HZ 240000000
|
||||
#define CONFIG_ESP_CONSOLE_ROM_SERIAL_PORT_NUM 4
|
||||
#define CONFIG_ESP_TIMER_INTERRUPT_LEVEL 1
|
||||
#define CONFIG_BOOTLOADER_LOG_LEVEL 3
|
||||
#define CONFIG_LOG_TIMESTAMP_SOURCE_RTOS 1
|
||||
#define CONFIG_ESP32_DPORT_DIS_INTERRUPT_LVL 5
|
||||
#define CONFIG_ESP_SYSTEM_SINGLE_CORE_MODE 1
|
||||
#define CONFIG_IDF_TARGET_ARCH_XTENSA 1
|
||||
#define CONFIG_SPI_FLASH_PLACE_FUNCTIONS_IN_IRAM 1
|
||||
#define CONFIG_ESP_PHY_ENABLED 1
|
||||
#define CONFIG_portNUM_PROCESSORS 2
|
||||
#define CONFIG_IDF_FIRMWARE_CHIP_ID 0x0009
|
||||
#define CONFIG_SPIRAM_ALLOW_BSS_SEG_EXTERNAL_MEMORY 1
|
||||
#define CONFIG_SPIRAM_ALLOW_NOINIT_SEG_EXTERNAL_MEMORY 1
|
||||
#define CONFIG_IDF_TARGET_ESP32S3 1
|
||||
#define CONFIG_ESP_TIMER_IMPL_SYSTIMER 1
|
||||
#define CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_0 1
|
||||
#define CONFIG_ESP_SLEEP_WAIT_FLASH_READY_EXTRA_DELAY 2000
|
||||
#define CONFIG_ZEPHYR_HAL_ESPRESSIF_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_ETHOS_U_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_GIGADEVICE_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_INFINEON_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_INTEL_MODULE 1
|
||||
#define CONFIG_ZEPHYR_MICROCHIP_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_NORDIC_MODULE 1
|
||||
#define CONFIG_ZEPHYR_NUVOTON_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_NXP_MODULE 1
|
||||
#define CONFIG_ZEPHYR_OPENISA_MODULE 1
|
||||
#define CONFIG_ZEPHYR_QUICKLOGIC_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_REALTEK_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_RENESAS_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_RPI_PICO_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_SIFLI_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_SILABS_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_ST_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_STM32_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_TDK_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_TELINK_MODULE 1
|
||||
#define CONFIG_ZEPHYR_TI_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_WCH_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HAL_WURTHELEKTRONIK_MODULE 1
|
||||
#define CONFIG_ZEPHYR_XTENSA_MODULE 1
|
||||
#define CONFIG_ZEPHYR_HOSTAP_MODULE 1
|
||||
#define CONFIG_ZEPHYR_LIBLC3_MODULE 1
|
||||
#define CONFIG_ZEPHYR_LIBMCTP_MODULE 1
|
||||
#define CONFIG_ZEPHYR_LIBMETAL_MODULE 1
|
||||
#define CONFIG_ZEPHYR_LIBSBC_MODULE 1
|
||||
#define CONFIG_ZEPHYR_LITTLEFS_MODULE 1
|
||||
#define CONFIG_ZEPHYR_LORA_BASICS_MODEM_MODULE 1
|
||||
#define CONFIG_ZEPHYR_LORAMAC_NODE_MODULE 1
|
||||
#define CONFIG_HAS_SEMTECH_RADIO_DRIVERS 1
|
||||
#define CONFIG_HAS_SEMTECH_SX126X 1
|
||||
#define CONFIG_ZEPHYR_LVGL_MODULE 1
|
||||
#define CONFIG_ZEPHYR_MBEDTLS_MODULE 1
|
||||
#define CONFIG_MBEDTLS_VERSION_4_x 1
|
||||
#define CONFIG_ZEPHYR_MBEDTLS_3_6_MODULE 1
|
||||
#define CONFIG_ZEPHYR_MCUBOOT_MODULE 1
|
||||
#define CONFIG_ZEPHYR_MIPI_SYS_T_MODULE 1
|
||||
#define CONFIG_ZEPHYR_NANOPB_MODULE 1
|
||||
#define CONFIG_ZEPHYR_NRF_WIFI_MODULE 1
|
||||
#define CONFIG_ZEPHYR_OPEN_AMP_MODULE 1
|
||||
#define CONFIG_ZEPHYR_OPENTHREAD_MODULE 1
|
||||
#define CONFIG_ZEPHYR_PERCEPIO_MODULE 1
|
||||
#define CONFIG_ZEPHYR_PICOLIBC_MODULE 1
|
||||
#define CONFIG_ZEPHYR_PSA_ARCH_TESTS_MODULE 1
|
||||
#define CONFIG_ZEPHYR_SEGGER_MODULE 1
|
||||
#define CONFIG_ZEPHYR_TF_M_TESTS_MODULE 1
|
||||
#define CONFIG_ZEPHYR_TF_PSA_CRYPTO_MODULE 1
|
||||
#define CONFIG_ZEPHYR_TRUSTED_FIRMWARE_A_MODULE 1
|
||||
#define CONFIG_ZEPHYR_TRUSTED_FIRMWARE_M_MODULE 1
|
||||
#define CONFIG_ZEPHYR_UOSCORE_UEDHOC_MODULE 1
|
||||
#define CONFIG_ZEPHYR_ZCBOR_MODULE 1
|
||||
#define CONFIG_ZEPHYR_NRF_HW_MODELS_MODULE 1
|
||||
#define CONFIG_HAS_ESPRESSIF_HAL 1
|
||||
#define CONFIG_BOARD "xiao_esp32s3"
|
||||
#define CONFIG_BOARD_REVISION ""
|
||||
#define CONFIG_BOARD_TARGET "xiao_esp32s3/esp32s3/procpu"
|
||||
#define CONFIG_BOARD_XIAO_ESP32S3 1
|
||||
#define CONFIG_BOARD_XIAO_ESP32S3_ESP32S3_PROCPU 1
|
||||
#define CONFIG_BOARD_QUALIFIERS "esp32s3/procpu"
|
||||
#define CONFIG_HEAP_MEM_POOL_ADD_SIZE_BOARD 4096
|
||||
#define CONFIG_SOC "esp32s3"
|
||||
#define CONFIG_SOC_SERIES "esp32s3"
|
||||
#define CONFIG_SOC_FAMILY "espressif_esp32"
|
||||
#define CONFIG_SOC_PART_NUMBER "ESP32S3_WROOM_N8R8"
|
||||
#define CONFIG_SOC_FAMILY_ESPRESSIF_ESP32 1
|
||||
#define CONFIG_SOC_SERIES_ESP32S3 1
|
||||
#define CONFIG_SOC_ESP32S3_WROOM_N8R8 1
|
||||
#define CONFIG_SOC_ESP32S3 1
|
||||
#define CONFIG_SOC_ESP32S3_PROCPU 1
|
||||
#define CONFIG_GPIO_INIT_PRIORITY 40
|
||||
#define CONFIG_ESP_SIMPLE_BOOT 1
|
||||
#define CONFIG_ESP32_TIMER_TASK_STACK_SIZE 4096
|
||||
#define CONFIG_ESP32_TIMER_TASK_PRIO 3
|
||||
#define CONFIG_ESP_CONSOLE_UART_NUM 4
|
||||
#define CONFIG_ESP_CONSOLE_UART_BAUDRATE 1
|
||||
#define CONFIG_ESP_ROM_USB_SERIAL_DEVICE_NUM 4
|
||||
#define CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG 1
|
||||
#define CONFIG_ESP_CONSOLE 1
|
||||
#define CONFIG_ESP_USB_SERIAL_JTAG_ENABLED 1
|
||||
#define CONFIG_ESP32_EFUSE_MAX_BLK_LEN 256
|
||||
#define CONFIG_ESPTOOLPY_FLASH_MODE_AUTO_DETECT 1
|
||||
#define CONFIG_ESPTOOLPY_FLASHMODE_DIO 1
|
||||
#define CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_STR 1
|
||||
#define CONFIG_ESPTOOLPY_FLASHMODE "dio"
|
||||
#define CONFIG_ESPTOOLPY_FLASHFREQ_80M 1
|
||||
#define CONFIG_ESPTOOLPY_FLASHFREQ_80M_DEFAULT 1
|
||||
#define CONFIG_ESPTOOLPY_FLASHFREQ "80m"
|
||||
#define CONFIG_ESPTOOLPY_FLASHSIZE_2MB 1
|
||||
#define CONFIG_ESPTOOLPY_FLASHSIZE "2MB"
|
||||
#define CONFIG_ESPTOOLPY_BEFORE_RESET 1
|
||||
#define CONFIG_ESPTOOLPY_BEFORE "default_reset"
|
||||
#define CONFIG_ESPTOOLPY_AFTER_RESET 1
|
||||
#define CONFIG_ESPTOOLPY_AFTER "hard_reset"
|
||||
#define CONFIG_MMU_PAGE_SIZE 0x10000
|
||||
#define CONFIG_SPI_FLASH_VENDOR_MXIC_SUPPORTED 1
|
||||
#define CONFIG_SPI_FLASH_SUPPORT_ISSI_CHIP 1
|
||||
#define CONFIG_SPI_FLASH_SUPPORT_MXIC_CHIP 1
|
||||
#define CONFIG_SPI_FLASH_SUPPORT_GD_CHIP 1
|
||||
#define CONFIG_SPI_FLASH_SUPPORT_WINBOND_CHIP 1
|
||||
#define CONFIG_SPI_FLASH_SUPPORT_BOYA_CHIP 1
|
||||
#define CONFIG_SPI_FLASH_SUPPORT_TH_CHIP 1
|
||||
#define CONFIG_SPI_FLASH_SUPPORT_MXIC_OPI_CHIP 1
|
||||
#define CONFIG_SPI_FLASH_ROM_DRIVER_PATCH 1
|
||||
#define CONFIG_BOOTLOADER_FLASH_XMC_SUPPORT 1
|
||||
#define CONFIG_BOOTLOADER_VDDSDIO_BOOST_1_9V 1
|
||||
#define CONFIG_ESP32S3_INSTRUCTION_CACHE_16KB 1
|
||||
#define CONFIG_ESP32S3_INSTRUCTION_CACHE_SIZE 0x4000
|
||||
#define CONFIG_ESP32S3_INSTRUCTION_CACHE_8WAYS 1
|
||||
#define CONFIG_ESP32S3_ICACHE_ASSOCIATED_WAYS 8
|
||||
#define CONFIG_ESP32S3_INSTRUCTION_CACHE_LINE_32B 1
|
||||
#define CONFIG_ESP32S3_INSTRUCTION_CACHE_LINE_SIZE 32
|
||||
#define CONFIG_ESP32S3_DATA_CACHE_32KB 1
|
||||
#define CONFIG_ESP32S3_DATA_CACHE_SIZE 0x8000
|
||||
#define CONFIG_ESP32S3_DATA_CACHE_8WAYS 1
|
||||
#define CONFIG_ESP32S3_DCACHE_ASSOCIATED_WAYS 8
|
||||
#define CONFIG_ESP32S3_DATA_CACHE_LINE_32B 1
|
||||
#define CONFIG_ESP32S3_DATA_CACHE_LINE_SIZE 32
|
||||
#define CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_STA 1
|
||||
#define CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_AP 1
|
||||
#define CONFIG_ESP_MAC_ADDR_UNIVERSE_ETH 1
|
||||
#define CONFIG_ESP_MAC_ADDR_UNIVERSE_BT 1
|
||||
#define CONFIG_ESP_MAC_UNIVERSAL_MAC_ADDRESSES_FOUR 1
|
||||
#define CONFIG_ESP32S3_UNIVERSAL_MAC_ADDRESSES_FOUR 1
|
||||
#define CONFIG_ESP32S3_UNIVERSAL_MAC_ADDRESSES 4
|
||||
#define CONFIG_RESERVE_RTC_MEM 0
|
||||
#define CONFIG_SOC_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_SOC_LOG_LEVEL 3
|
||||
#define CONFIG_ARCH "xtensa"
|
||||
#define CONFIG_XTENSA 1
|
||||
#define CONFIG_ARCH_IS_SET 1
|
||||
#define CONFIG_ARCH_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_ARCH_LOG_LEVEL 3
|
||||
#define CONFIG_LITTLE_ENDIAN 1
|
||||
#define CONFIG_SRAM_SIZE 416
|
||||
#define CONFIG_SRAM_BASE_ADDRESS 0x3fc88000
|
||||
#define CONFIG_ARCH_DEVICE_STATE_ALIGN 4
|
||||
#define CONFIG_SRAM_SW_ISR_TABLE 1
|
||||
#define CONFIG_EXCEPTION_DEBUG 1
|
||||
#define CONFIG_ARCH_HAS_TIMING_FUNCTIONS 1
|
||||
#define CONFIG_ARCH_SUPPORTS_COREDUMP 1
|
||||
#define CONFIG_ARCH_SUPPORTS_COREDUMP_STACK_PTR 1
|
||||
#define CONFIG_ARCH_HAS_CODE_DATA_RELOCATION 1
|
||||
#define CONFIG_CPU_HAS_FPU 1
|
||||
#define CONFIG_ARCH_HAS_DIRECTED_IPIS 1
|
||||
#define CONFIG_TOOLCHAIN_HAS_BUILTIN_FFS 1
|
||||
#define CONFIG_KERNEL_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_KERNEL_LOG_LEVEL 3
|
||||
#define CONFIG_NUM_COOP_PRIORITIES 16
|
||||
#define CONFIG_MAIN_THREAD_PRIORITY 0
|
||||
#define CONFIG_COOP_ENABLED 1
|
||||
#define CONFIG_PREEMPT_ENABLED 1
|
||||
#define CONFIG_PRIORITY_CEILING -128
|
||||
#define CONFIG_THREAD_STACK_INFO 1
|
||||
#define CONFIG_SCHED_SIMPLE 1
|
||||
#define CONFIG_WAITQ_SIMPLE 1
|
||||
#define CONFIG_ERRNO 1
|
||||
#define CONFIG_BOOT_BANNER 1
|
||||
#define CONFIG_BOOT_BANNER_STRING "Booting Zephyr OS build"
|
||||
#define CONFIG_BOOT_DELAY 0
|
||||
#define CONFIG_SYSTEM_WORKQUEUE_PRIORITY -1
|
||||
#define CONFIG_SYSTEM_WORKQUEUE_WORK_TIMEOUT_MS 0
|
||||
#define CONFIG_ATOMIC_OPERATIONS_BUILTIN 1
|
||||
#define CONFIG_TIMESLICING 1
|
||||
#define CONFIG_TIMESLICE_PRIORITY 0
|
||||
#define CONFIG_POLL 1
|
||||
#define CONFIG_NUM_MBOX_ASYNC_MSGS 10
|
||||
#define CONFIG_HEAP_MEM_POOL_SIZE 4096
|
||||
#define CONFIG_TIMEOUT_64BIT 1
|
||||
#define CONFIG_SYS_CLOCK_MAX_TIMEOUT_DAYS 365
|
||||
#define CONFIG_USE_SWITCH 1
|
||||
#define CONFIG_USE_SWITCH_SUPPORTED 1
|
||||
#define CONFIG_TOOLCHAIN_SUPPORTS_THREAD_LOCAL_STORAGE 1
|
||||
#define CONFIG_TOOLCHAIN_SUPPORTS_STATIC_INIT_GNU 1
|
||||
#define CONFIG_KERNEL_INIT_PRIORITY_OBJECTS 30
|
||||
#define CONFIG_KERNEL_INIT_PRIORITY_LIBC 35
|
||||
#define CONFIG_KERNEL_INIT_PRIORITY_DEFAULT 40
|
||||
#define CONFIG_KERNEL_INIT_PRIORITY_DEVICE 50
|
||||
#define CONFIG_APPLICATION_INIT_PRIORITY 90
|
||||
#define CONFIG_CLOCK_CONTROL_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_CLOCK_CONTROL_LOG_LEVEL 3
|
||||
#define CONFIG_CLOCK_CONTROL_ESP32 1
|
||||
#define CONFIG_CLOCK_CONTROL_ESP32_RTC_CLK_SRC_INT_RC 1
|
||||
#define CONFIG_CLOCK_CONTROL_ESP32_RTC_CLK_CAL_CYCLES 1024
|
||||
#define CONFIG_CLOCK_CONTROL_TISCI_PRIORITY 40
|
||||
#define CONFIG_CONSOLE_INPUT_MAX_LINE_LEN 128
|
||||
#define CONFIG_CONSOLE_HAS_DRIVER 1
|
||||
#define CONFIG_CONSOLE_INIT_PRIORITY 60
|
||||
#define CONFIG_UART_CONSOLE 1
|
||||
#define CONFIG_UART_CONSOLE_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_UART_CONSOLE_LOG_LEVEL 3
|
||||
#define CONFIG_GPIO_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_GPIO_LOG_LEVEL 3
|
||||
#define CONFIG_GPIO_ESP32 1
|
||||
#define CONFIG_INTC_INIT_PRIORITY 40
|
||||
#define CONFIG_INTC_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_INTC_LOG_LEVEL 3
|
||||
#define CONFIG_INTC_ESP32 1
|
||||
#define CONFIG_LORA 1
|
||||
#define CONFIG_LORA_MODULE_BACKEND_LORAMAC_NODE 1
|
||||
#define CONFIG_LORA_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_LORA_LOG_LEVEL 3
|
||||
#define CONFIG_LORA_INIT_PRIORITY 90
|
||||
#define CONFIG_LORA_SX126X 1
|
||||
#define CONFIG_PINCTRL 1
|
||||
#define CONFIG_PINCTRL_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_PINCTRL_LOG_LEVEL 3
|
||||
#define CONFIG_PINCTRL_ESP32 1
|
||||
#define CONFIG_SERIAL_HAS_DRIVER 1
|
||||
#define CONFIG_SERIAL_SUPPORT_ASYNC 1
|
||||
#define CONFIG_SERIAL_SUPPORT_INTERRUPT 1
|
||||
#define CONFIG_SERIAL_INIT_PRIORITY 50
|
||||
#define CONFIG_UART_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_UART_LOG_LEVEL 3
|
||||
#define CONFIG_UART_ESP32 1
|
||||
#define CONFIG_SERIAL_ESP32_USB 1
|
||||
#define CONFIG_UART_ESP32_TX_FIFO_THRESH 0x1
|
||||
#define CONFIG_UART_ESP32_RX_FIFO_THRESH 0x16
|
||||
#define CONFIG_SPI_INIT_PRIORITY 50
|
||||
#define CONFIG_SPI_COMPLETION_TIMEOUT_TOLERANCE 200
|
||||
#define CONFIG_SPI_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_SPI_LOG_LEVEL 3
|
||||
#define CONFIG_ESP32_SPIM 1
|
||||
#define CONFIG_SYSTEM_CLOCK_INIT_PRIORITY 0
|
||||
#define CONFIG_TICKLESS_CAPABLE 1
|
||||
#define CONFIG_XTENSA_TIMER_LPM_TIMER_NONE 1
|
||||
#define CONFIG_FULL_LIBC_SUPPORTED 1
|
||||
#define CONFIG_MINIMAL_LIBC_SUPPORTED 1
|
||||
#define CONFIG_PICOLIBC_SUPPORTED 1
|
||||
#define CONFIG_PICOLIBC 1
|
||||
#define CONFIG_COMMON_LIBC_ABORT 1
|
||||
#define CONFIG_COMMON_LIBC_TIME 1
|
||||
#define CONFIG_COMMON_LIBC_MALLOC 1
|
||||
#define CONFIG_COMMON_LIBC_CALLOC 1
|
||||
#define CONFIG_COMMON_LIBC_REALLOCARRAY 1
|
||||
#define CONFIG_PICOLIBC_USE_TOOLCHAIN 1
|
||||
#define CONFIG_PICOLIBC_IO_LONG_LONG 1
|
||||
#define CONFIG_STDOUT_CONSOLE 1
|
||||
#define CONFIG_NEED_LIBC_MEM_PARTITION 1
|
||||
#define CONFIG_SYS_HEAP_ALLOC_LOOPS 3
|
||||
#define CONFIG_SYS_HEAP_ARRAY_SIZE 0
|
||||
#define CONFIG_SYS_HEAP_HARDENING_BASIC 1
|
||||
#define CONFIG_SYS_HEAP_HARDENING_LEVEL 1
|
||||
#define CONFIG_SYS_HEAP_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_SYS_HEAP_LOG_LEVEL 3
|
||||
#define CONFIG_SYS_HEAP_AUTO 1
|
||||
#define CONFIG_MPSC_PBUF 1
|
||||
#define CONFIG_HAS_POWEROFF 1
|
||||
#define CONFIG_CBPRINTF_COMPLETE 1
|
||||
#define CONFIG_CBPRINTF_FULL_INTEGRAL 1
|
||||
#define CONFIG_CBPRINTF_PACKAGE_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_CBPRINTF_PACKAGE_LOG_LEVEL 3
|
||||
#define CONFIG_CBPRINTF_CONVERT_CHECK_PTR 1
|
||||
#define CONFIG_CPU_LOAD_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_CPU_LOAD_LOG_LEVEL 3
|
||||
#define CONFIG_POSIX_AEP_CHOICE_ZEPHYR 1
|
||||
#define CONFIG_TC_PROVIDES_POSIX_C_LANG_SUPPORT_R 1
|
||||
#define CONFIG_POSIX_C_LANG_SUPPORT_R 1
|
||||
#define CONFIG_POSIX_C_LIB_EXT 1
|
||||
#define CONFIG_LIBGCC_RTLIB 1
|
||||
#define CONFIG_RING_BUFFER 1
|
||||
#define CONFIG_GETOPT 1
|
||||
#define CONFIG_TIMEUTIL_APPLY_SKEW 1
|
||||
#define CONFIG_PRINTK 1
|
||||
#define CONFIG_EARLY_CONSOLE 1
|
||||
#define CONFIG_ASSERT_VERBOSE 1
|
||||
#define CONFIG_CPU_LOAD_LOG_PERIODICALLY 0
|
||||
#define CONFIG_LOG_CORE_INIT_PRIORITY 0
|
||||
#define CONFIG_LOG_MODE_DEFERRED 1
|
||||
#define CONFIG_LOG_FLUSH_SLEEP_US 10000
|
||||
#define CONFIG_LOG_DEFAULT_LEVEL 3
|
||||
#define CONFIG_LOG_OVERRIDE_LEVEL 0
|
||||
#define CONFIG_LOG_MAX_LEVEL 4
|
||||
#define CONFIG_LOG_PRINTK 1
|
||||
#define CONFIG_LOG_MODE_OVERFLOW 1
|
||||
#define CONFIG_LOG_PROCESS_TRIGGER_THRESHOLD 10
|
||||
#define CONFIG_LOG_PROCESS_THREAD 1
|
||||
#define CONFIG_LOG_PROCESS_THREAD_STARTUP_DELAY_MS 0
|
||||
#define CONFIG_LOG_PROCESS_THREAD_SLEEP_MS 1000
|
||||
#define CONFIG_LOG_BUFFER_SIZE 1024
|
||||
#define CONFIG_LOG_TRACE_SHORT_TIMESTAMP 1
|
||||
#define CONFIG_LOG_FUNC_NAME_PREFIX_DBG 1
|
||||
#define CONFIG_LOG_BACKEND_SHOW_TIMESTAMP 1
|
||||
#define CONFIG_LOG_BACKEND_SHOW_LEVEL 1
|
||||
#define CONFIG_LOG_BACKEND_SHOW_COLOR 1
|
||||
#define CONFIG_LOG_TAG_MAX_LEN 0
|
||||
#define CONFIG_LOG_BACKEND_SUPPORTS_FORMAT_TIMESTAMP 1
|
||||
#define CONFIG_LOG_BACKEND_FORMAT_TIMESTAMP 1
|
||||
#define CONFIG_LOG_OUTPUT_FORMAT_TIME_TIMESTAMP 1
|
||||
#define CONFIG_LOG_BACKEND_UART 1
|
||||
#define CONFIG_LOG_BACKEND_UART_BUFFER_SIZE 1
|
||||
#define CONFIG_LOG_BACKEND_UART_AUTOSTART 1
|
||||
#define CONFIG_LOG_BACKEND_UART_OUTPUT_TEXT 1
|
||||
#define CONFIG_LOG_BACKEND_UART_OUTPUT_DEFAULT 0
|
||||
#define CONFIG_LOG_USE_VLA 1
|
||||
#define CONFIG_LOG_SIMPLE_MSG_OPTIMIZE 1
|
||||
#define CONFIG_LOG_FAILURE_REPORT_PERIOD 1000
|
||||
#define CONFIG_LOG_RATELIMIT 1
|
||||
#define CONFIG_LOG_RATELIMIT_INTERVAL_MS 5000
|
||||
#define CONFIG_LOG_OUTPUT 1
|
||||
#define CONFIG_HAS_PM 1
|
||||
#define CONFIG_TIMER_RANDOM_INITIAL_STATE 123456789
|
||||
#define CONFIG_ENTROPY_NODE_ENABLED 1
|
||||
#define CONFIG_COVERAGE_DUMP_PATH_EXCLUDE ""
|
||||
#define CONFIG_TOOLCHAIN_ZEPHYR_1_0 1
|
||||
#define CONFIG_TOOLCHAIN_ZEPHYR_SUPPORTS_THREAD_LOCAL_STORAGE 1
|
||||
#define CONFIG_TOOLCHAIN_ZEPHYR_SUPPORTS_GNU_EXTENSIONS 1
|
||||
#define CONFIG_PICOLIBC_DEFAULT 1
|
||||
#define CONFIG_LINKER_ORPHAN_SECTION_WARN 1
|
||||
#define CONFIG_FLASH_LOAD_SIZE 0x0
|
||||
#define CONFIG_ROM_END_OFFSET 0x0
|
||||
#define CONFIG_LD_LINKER_SCRIPT_SUPPORTED 1
|
||||
#define CONFIG_LD_LINKER_TEMPLATE 1
|
||||
#define CONFIG_LINKER_SORT_BY_ALIGNMENT 1
|
||||
#define CONFIG_LINKER_GENERIC_SECTIONS_PRESENT_AT_BOOT 1
|
||||
#define CONFIG_LINKER_ITERABLE_SUBALIGN 4
|
||||
#define CONFIG_STD_C17 1
|
||||
#define CONFIG_TOOLCHAIN_SUPPORTS_GNU_EXTENSIONS 1
|
||||
#define CONFIG_SIZE_OPTIMIZATIONS 1
|
||||
#define CONFIG_COMPILER_TRACK_MACRO_EXPANSION 1
|
||||
#define CONFIG_COMPILER_COLOR_DIAGNOSTICS 1
|
||||
#define CONFIG_FORTIFY_SOURCE_COMPILE_TIME 1
|
||||
#define CONFIG_COMPILER_OPT ""
|
||||
#define CONFIG_TOOLCHAIN_SUPPORTS_VLA_IN_STATEMENTS 1
|
||||
#define CONFIG_TOOLCHAIN_SUPPORTS_VARIABLE_CLEANUP_ATTRIBUTE 1
|
||||
#define CONFIG_COMPILER_CODEGEN_VLIW_AUTO 1
|
||||
#define CONFIG_RUNTIME_ERROR_CHECKS 1
|
||||
#define CONFIG_KERNEL_BIN_NAME "zephyr"
|
||||
#define CONFIG_OUTPUT_STAT 1
|
||||
#define CONFIG_OUTPUT_PRINT_MEMORY_USAGE 1
|
||||
#define CONFIG_BUILD_GAP_FILL_PATTERN 0xFF
|
||||
#define CONFIG_BUILD_OUTPUT_STRIP_PATHS 1
|
||||
#define CONFIG_CHECK_INIT_PRIORITIES 1
|
||||
#define CONFIG_WARN_DEPRECATED 1
|
||||
#define CONFIG_ENFORCE_ZEPHYR_STDINT 1
|
||||
#define CONFIG_LEGACY_GENERATED_INCLUDE_PATH 1
|
||||
#define CONFIG_LORAMODEM_KISS_IFACE_UART 1
|
||||
#define CONFIG_LORAMODEM_LORA_FREQ_HZ 869618000
|
||||
#define CONFIG_LORAMODEM_LORA_SF 8
|
||||
#define CONFIG_LORAMODEM_LORA_BW 62
|
||||
#define CONFIG_LORAMODEM_LORA_CR 5
|
||||
#define CONFIG_LORAMODEM_LORA_TX_POWER_DBM 21
|
||||
#define CONFIG_LORAMODEM_LORA_PREAMBLE_LEN 8
|
||||
#define CONFIG_LORAMODEM_MAX_PACKET_SIZE 255
|
||||
812
build/zephyr/include/generated/zephyr/core-isa-dM.h
Normal file
812
build/zephyr/include/generated/zephyr/core-isa-dM.h
Normal file
@@ -0,0 +1,812 @@
|
||||
#define XCHAL_MMU_ASID_BITS 0
|
||||
#define __DBL_MIN_EXP__ (-1021)
|
||||
#define __XCHAL_HAVE_FP 1
|
||||
#define XCHAL_VECBASE_RESET_VADDR 0x40000000
|
||||
#define XCHAL_HAVE_FP_RECIP 1
|
||||
#define XCHAL_HAVE_PIF_REQ_ATTR 1
|
||||
#define XCHAL_PREFETCH_CASTOUT_LINES 0
|
||||
#define XCHAL_DCACHE_WAYS 1
|
||||
#define __UINT_LEAST16_MAX__ 0xffff
|
||||
#define XCHAL_CORE_ID "LX7_ESP32_S3_MP"
|
||||
#define __ATOMIC_ACQUIRE 2
|
||||
#define XCHAL_INT25_LEVEL 4
|
||||
#define __WCHAR_MAX__ 0xffff
|
||||
#define XCHAL_PROFILING_INTERRUPT 11
|
||||
#define XCHAL_INT22_EXTNUM 17
|
||||
#define __FLT_MIN__ 1.1754943508222875e-38F
|
||||
#define __GCC_IEC_559_COMPLEX 0
|
||||
#define __XCHAL_HAVE_PREDICTED_BRANCHES 0
|
||||
#define XCHAL_DCACHE_ACCESS_SIZE 1
|
||||
#define XCHAL_EXTINT16_NUM 21
|
||||
#define __UINT_LEAST8_TYPE__ unsigned char
|
||||
#define XCHAL_HAVE_CONNXD2_DUALLSFLIX 0
|
||||
#define XCHAL_HAVE_INSTRAM0 1
|
||||
#define XCHAL_INT10_TYPE XTHAL_INTTYPE_EXTERN_EDGE
|
||||
#define XCHAL_INT19_LEVEL 2
|
||||
#define XCHAL_HAVE_SEXT 1
|
||||
#define __INTMAX_C(c) c ## LL
|
||||
#define __XCHAL_HAVE_ADDX 1
|
||||
#define __CHAR_BIT__ 8
|
||||
#define __XCHAL_DCACHE_LINESIZE 16
|
||||
#define __XTENSA_MARCH_EARLIEST 270012
|
||||
#define XCHAL_INSTRAM0_HAVE_IDMA 0
|
||||
#define __XCHAL_DCACHE_LINEWIDTH 4
|
||||
#define __UINT8_MAX__ 0xff
|
||||
#define XCHAL_HW_MAX_VERSION_MINOR 12
|
||||
#define XCHAL_INTLEVEL5_VECTOR_VADDR 0x40000240
|
||||
#define XCHAL_PDX_SIMD32 0
|
||||
#define __WINT_MAX__ 0xffffffffU
|
||||
#define __FLT32_MIN_EXP__ (-125)
|
||||
#define XCHAL_HAVE_VISION 0
|
||||
#define XCHAL_ICACHE_ACCESS_SIZE 1
|
||||
#define XCHAL_VISION_TYPE 0
|
||||
#define XCHAL_RESET_VECTOR_PADDR 0x40000400
|
||||
#define XCHAL_INT4_EXTNUM 4
|
||||
#define XCHAL_INT21_LEVEL 2
|
||||
#define XCHAL_INT9_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define __ORDER_LITTLE_ENDIAN__ 1234
|
||||
#define __SIZE_MAX__ 0xffffffffU
|
||||
#define XCHAL_INTTYPE_MASK_TIMER 0x00018040
|
||||
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 1
|
||||
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 1
|
||||
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 1
|
||||
#define __DBL_DENORM_MIN__ ((double)4.9406564584124654e-324L)
|
||||
#define __GCC_ATOMIC_CHAR_LOCK_FREE 2
|
||||
#define __GCC_IEC_559 0
|
||||
#define XCHAL_RESET_VECTOR1_PADDR 0x40000400
|
||||
#define __FLT32X_DECIMAL_DIG__ 17
|
||||
#define __FLT_EVAL_METHOD__ 0
|
||||
#define XCHAL_HAVE_CONST16 0
|
||||
#define XCHAL_TIMER3_INTERRUPT XTHAL_TIMER_UNCONFIGURED
|
||||
#define __FLT64_DECIMAL_DIG__ 17
|
||||
#define XCHAL_HAVE_FUSION 0
|
||||
#define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2
|
||||
#define XCHAL_INTLEVEL7_MASK 0x00004000
|
||||
#define XCHAL_HAVE_VECBASE 1
|
||||
#define XCHAL_INTLEVEL4_VECOFS 0x00000200
|
||||
#define XCHAL_NUM_EXTINTERRUPTS 26
|
||||
#define XCHAL_WINDOW_OF12_VECOFS 0x00000100
|
||||
#define XCHAL_INTLEVEL5_ANDBELOW_MASK 0xFFFFBFFF
|
||||
#define XCHAL_HW_MAX_VERSION_MAJOR 2700
|
||||
#define __UINT_FAST64_MAX__ 0xffffffffffffffffULL
|
||||
#define XCHAL_HAVE_VECTRA1 0
|
||||
#define __SIG_ATOMIC_TYPE__ int
|
||||
#define XCHAL_INTLEVEL6_VECTOR_VADDR 0x40000280
|
||||
#define XCHAL_INT13_EXTNUM 10
|
||||
#define XCHAL_NUM_INSTRAM 1
|
||||
#define XCHAL_HAVE_TAP_MASTER 0
|
||||
#define __DBL_MIN_10_EXP__ (-307)
|
||||
#define __FINITE_MATH_ONLY__ 0
|
||||
#define XCHAL_HAVE_FLIX3 0
|
||||
#define __XCHAL_HAVE_L32R 1
|
||||
#define XCHAL_INTTYPE_MASK_GS_ERR 0x00000000
|
||||
#define __FLT32X_MAX_EXP__ 1024
|
||||
#define XCHAL_INT27_EXTNUM 22
|
||||
#define __GNUC_PATCHLEVEL__ 0
|
||||
#define __FLT32_HAS_DENORM__ 1
|
||||
#define XCHAL_INT31_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define XCHAL_CP_MAXCFG 8
|
||||
#define __UINT_FAST8_MAX__ 0xffffffffU
|
||||
#define __XCHAL_HAVE_LOOPS 1
|
||||
#define __FLT32_MAX_10_EXP__ 38
|
||||
#define __XCHAL_DEBUGLEVEL 6
|
||||
#define XCHAL_WINDOW_UF4_VECOFS 0x00000040
|
||||
#define __INT8_C(c) c
|
||||
#define XCHAL_UNALIGNED_LOAD_EXCEPTION 0
|
||||
#define XCHAL_HAVE_CLAMPS 1
|
||||
#define __XCHAL_HAVE_DFP_RECIP 0
|
||||
#define __INT_LEAST8_WIDTH__ 8
|
||||
#define __UINT_LEAST64_MAX__ 0xffffffffffffffffULL
|
||||
#define XCHAL_NUM_LOADSTORE_UNITS 1
|
||||
#define __SHRT_MAX__ 0x7fff
|
||||
#define XCHAL_DEBUG_VECTOR_VADDR XCHAL_INTLEVEL6_VECTOR_VADDR
|
||||
#define __XCHAL_DATA_WIDTH 16
|
||||
#define __LDBL_MAX__ 1.7976931348623157e+308L
|
||||
#define XCHAL_INT30_EXTNUM 24
|
||||
#define __XCHAL_ICACHE_LINESIZE 16
|
||||
#define XCHAL_MPU_ALIGN_BITS 0
|
||||
#define __LDBL_IS_IEC_60559__ 1
|
||||
#define __XCHAL_UNALIGNED_LOAD_HW 0
|
||||
#define XCHAL_INTLEVEL7_VECTOR_VADDR XCHAL_NMI_VECTOR_VADDR
|
||||
#define __UINT_LEAST8_MAX__ 0xff
|
||||
#define __GCC_ATOMIC_BOOL_LOCK_FREE 2
|
||||
#define XCHAL_INT20_LEVEL 2
|
||||
#define XCHAL_INT9_EXTNUM 7
|
||||
#define __UINTMAX_TYPE__ long long unsigned int
|
||||
#define XCHAL_INT17_LEVEL 1
|
||||
#define __FLT_EVAL_METHOD_TS_18661_3__ 0
|
||||
#define XCHAL_HAVE_ABS 1
|
||||
#define XCHAL_NUM_INSTROM 0
|
||||
#define XCHAL_HAVE_DCACHE_TEST 0
|
||||
#define XCHAL_HAVE_PREFETCH 0
|
||||
#define __UINT32_MAX__ 0xffffffffUL
|
||||
#define XCHAL_HAVE_GRIVPEP_HISTOGRAM 0
|
||||
#define XCHAL_DCACHE_IS_COHERENT 0
|
||||
#define XCHAL_NUM_URAM 0
|
||||
#define XCHAL_HAVE_MAC16 1
|
||||
#define __LDBL_MAX_EXP__ 1024
|
||||
#define XCHAL_NUM_DBREAK 2
|
||||
#define __WINT_MIN__ 0U
|
||||
#define XCHAL_EXTINT14_NUM 19
|
||||
#define XCHAL_HAVE_FUSION_VITERBI 0
|
||||
#define XCHAL_HAVE_RELEASE_SYNC 1
|
||||
#define __FLT32X_IS_IEC_60559__ 1
|
||||
#define XCHAL_HAVE_IMEM_LOADSTORE 1
|
||||
#define __XCHAL_HAVE_THREADPTR 1
|
||||
#define __INT_LEAST16_WIDTH__ 16
|
||||
#define __SCHAR_MAX__ 0x7f
|
||||
#define XCHAL_INT8_LEVEL 1
|
||||
#define XCHAL_INT18_EXTNUM 13
|
||||
#define __WCHAR_MIN__ 0
|
||||
#define __XCHAL_ICACHE_LINEWIDTH 4
|
||||
#define XCHAL_DATARAM0_VADDR 0x3C000000
|
||||
#define __INT64_C(c) c ## LL
|
||||
#define __GCC_ATOMIC_POINTER_LOCK_FREE 2
|
||||
#define XCHAL_INT15_TYPE XTHAL_INTTYPE_TIMER
|
||||
#define XCHAL_DCACHE_LINE_LOCKABLE 0
|
||||
#define XCHAL_INT0_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define __ATOMIC_SEQ_CST 5
|
||||
#define XCHAL_CLOCK_GATING_GLOBAL 1
|
||||
#define XCHAL_HAVE_FUSIONG_SP_VFPU 0
|
||||
#define XCHAL_INT30_TYPE XTHAL_INTTYPE_EXTERN_EDGE
|
||||
#define XCHAL_EXTINT25_NUM 31
|
||||
#define __SIZEOF_INT__ 4
|
||||
#define XCHAL_DATARAM0_HAVE_IDMA 0
|
||||
#define XCHAL_INT27_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define XCHAL_INT6_LEVEL 1
|
||||
#define XCHAL_HAVE_CALL4AND12 1
|
||||
#define XCHAL_INT15_LEVEL 3
|
||||
#define __FLT32X_MANT_DIG__ 53
|
||||
#define XCHAL_INT21_EXTNUM 16
|
||||
#define XCHAL_HAVE_SSP16 0
|
||||
#define XCHAL_MPU_BACKGROUND_ENTRIES 0
|
||||
#define XCHAL_ICACHE_SIZE 0
|
||||
#define XCHAL_INT11_TYPE XTHAL_INTTYPE_PROFILING
|
||||
#define __STDC_HOSTED__ 1
|
||||
#define XCHAL_INST_FETCH_WIDTH 4
|
||||
#define XCHAL_HW_VERSION 270012
|
||||
#define XCHAL_INT4_LEVEL 1
|
||||
#define XCHAL_INT13_LEVEL 1
|
||||
#define XCHAL_VISION_SIMD16 0
|
||||
#define XCHAL_HAVE_ACELITE 0
|
||||
#define XCHAL_HAVE_FUSION_LOW_POWER 0
|
||||
#define XCHAL_INT12_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define __XCHAL_HAVE_MUL32 1
|
||||
#define __XTENSA_EL__ 1
|
||||
#define XCHAL_MMU_RING_BITS 0
|
||||
#define __DBL_DIG__ 15
|
||||
#define __XCHAL_HAVE_MUL16 1
|
||||
#define __FLT_EPSILON__ 1.1920928955078125e-7F
|
||||
#define XCHAL_HAVE_ABSOLUTE_LITERALS 0
|
||||
#define __SHRT_WIDTH__ 16
|
||||
#define XCHAL_INT3_EXTNUM 3
|
||||
#define __FLT32_IS_IEC_60559__ 1
|
||||
#define XCHAL_INT2_LEVEL 1
|
||||
#define XCHAL_HAVE_AXI 0
|
||||
#define XCHAL_INT11_LEVEL 3
|
||||
#define XCHAL_INTTYPE_MASK_UNCONFIGURED 0x00000000
|
||||
#define __LDBL_MIN__ 2.2250738585072014e-308L
|
||||
#define __STDC_UTF_16__ 1
|
||||
#define __DBL_IS_IEC_60559__ 1
|
||||
#define XCHAL_HAVE_MEM_ECC_PARITY 0
|
||||
#define XCHAL_HAVE_ADDX 1
|
||||
#define XCHAL_EXTINT10_NUM 13
|
||||
#define XCHAL_HAVE_TURBO16 0
|
||||
#define XCHAL_HAVE_OCD_LS32DDR 1
|
||||
#define XCHAL_HAVE_THREADPTR 1
|
||||
#define __XCHAL_HAVE_MMU 0
|
||||
#define __FLT32X_HAS_INFINITY__ 1
|
||||
#define __INT32_MAX__ 0x7fffffffL
|
||||
#define XCHAL_INT24_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define XCHAL_HAVE_DFP_accel XCHAL_HAVE_DFP_ACCEL
|
||||
#define __XCHAL_HAVE_DIV32 1
|
||||
#define __INT_WIDTH__ 32
|
||||
#define XCHAL_HAVE_PTP_MMU 0
|
||||
#define XCHAL_EXTINT24_NUM 30
|
||||
#define XCHAL_EXTINT9_NUM 12
|
||||
#define XCHAL_HAVE_PDX 0
|
||||
#define __XTENSA_MARCH_LATEST 270012
|
||||
#define __DECIMAL_DIG__ 17
|
||||
#define XCHAL_HAVE_DFP_ACCEL 0
|
||||
#define __FLT64_EPSILON__ 2.2204460492503131e-16F64
|
||||
#define XCHAL_INT12_EXTNUM 9
|
||||
#define __XCHAL_DCACHE_SIZE 0
|
||||
#define XCHAL_HW_VERSION_NAME "LX7.0.12"
|
||||
#define XCHAL_INT1_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define __LDBL_HAS_QUIET_NAN__ 1
|
||||
#define __XCHAL_HAVE_BOOLEANS 1
|
||||
#define XCHAL_HAVE_PIF 1
|
||||
#define __FLT64_MANT_DIG__ 53
|
||||
#define XCHAL_NUM_WRITEBUFFER_ENTRIES 4
|
||||
#define __XTHAL_ABI_WINDOWED 0
|
||||
#define XCHAL_WINDOW_VECTORS_VADDR 0x40000000
|
||||
#define XCHAL_DCACHE_BANKS 0
|
||||
#define XCHAL_DATARAM0_SIZE 67108864
|
||||
#define XCHAL_HAVE_HIGHPRI_INTERRUPTS 1
|
||||
#define XCHAL_INT28_TYPE XTHAL_INTTYPE_EXTERN_EDGE
|
||||
#define __GNUC__ 14
|
||||
#define XCHAL_INTTYPE_MASK_PROFILING 0x00000800
|
||||
#define __FLT_HAS_DENORM__ 1
|
||||
#define __SIZEOF_LONG_DOUBLE__ 8
|
||||
#define XCHAL_HAVE_EXCEPTIONS 1
|
||||
#define XCHAL_INTLEVEL5_VECOFS 0x00000240
|
||||
#define XCHAL_INTLEVEL6_MASK 0x00000000
|
||||
#define XCHAL_DATARAM0_BANKS 1
|
||||
#define XCHAL_HAVE_DFP_RSQRT 0
|
||||
#define __XCHAL_HAVE_CONST16 0
|
||||
#define __BIGGEST_ALIGNMENT__ 16
|
||||
#define XCHAL_BUILD_UNIQUE_ID 0x00090F1F
|
||||
#define XCHAL_NMI_VECTOR_PADDR 0x400002C0
|
||||
#define XCHAL_EXTINT12_NUM 17
|
||||
#define __FLT64_MAX_10_EXP__ 308
|
||||
#define XCHAL_HAVE_DATARAM0 1
|
||||
#define XCHAL_INT13_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define XCHAL_HAVE_DFPU_SINGLE_ONLY 1
|
||||
#define XCHAL_INT8_EXTNUM 6
|
||||
#define __DBL_MAX__ ((double)1.7976931348623157e+308L)
|
||||
#define __INT_FAST32_MAX__ 0x7fffffff
|
||||
#define __DBL_HAS_INFINITY__ 1
|
||||
#define XCHAL_HAVE_HIFI3_VFPU 0
|
||||
#define XCHAL_INT16_LEVEL 5
|
||||
#define XCHAL_HAVE_BBE16_DESPREAD 0
|
||||
#define __HAVE_SPECULATION_SAFE_VALUE 1
|
||||
#define XCHAL_HAVE_FP_DIV 1
|
||||
#define XCHAL_INTLEVEL2_VECTOR_PADDR 0x40000180
|
||||
#define XCHAL_EXTINT23_NUM 28
|
||||
#define XCHAL_EXTINT8_NUM 10
|
||||
#define __INTPTR_WIDTH__ 32
|
||||
#define XCHAL_HAVE_LOOPS 1
|
||||
#define XCHAL_NMI_INTERRUPT 14
|
||||
#define __UINT_LEAST32_MAX__ 0xffffffffUL
|
||||
#define XCHAL_DEBUGLEVEL 6
|
||||
#define __FLT32X_HAS_DENORM__ 1
|
||||
#define __INT_FAST16_TYPE__ int
|
||||
#define __XCHAL_HAVE_RELEASE_SYNC 1
|
||||
#define XCHAL_EXTINT13_NUM 18
|
||||
#define XCHAL_TIMER2_INTERRUPT 16
|
||||
#define __LDBL_HAS_DENORM__ 1
|
||||
#define XCHAL_HAVE_DEBUG_EXTERN_INT 1
|
||||
#define XCHAL_DATA_WIDTH 16
|
||||
#define XCHAL_INT17_EXTNUM 12
|
||||
#define __INT_LEAST32_MAX__ 0x7fffffffL
|
||||
#define XCHAL_MMU_RINGS 1
|
||||
#define XCHAL_HAVE_FUSION_LFSR_CRC 0
|
||||
#define XCHAL_INSTRAM0_PADDR 0x40000000
|
||||
#define __XCHAL_DCACHE_IS_WRITEBACK 0
|
||||
#define __DBL_MAX_EXP__ 1024
|
||||
#define XCHAL_HAVE_VISION_HP_VFPU 0
|
||||
#define __WCHAR_WIDTH__ 16
|
||||
#define __FLT32_MAX__ 3.4028234663852886e+38F32
|
||||
#define __GCC_ATOMIC_LONG_LOCK_FREE 2
|
||||
#define __XCHAL_UNALIGNED_STORE_HW 0
|
||||
#define __PTRDIFF_MAX__ 0x7fffffff
|
||||
#define XCHAL_HAVE_HIFI5_HP_VFPU 0
|
||||
#define XCHAL_DOUBLEEXC_VECOFS 0x000003C0
|
||||
#define XCHAL_HAVE_MUL32_HIGH 1
|
||||
#define XCHAL_WINDOW_UF8_VECOFS 0x000000C0
|
||||
#define XCHAL_INT30_LEVEL 4
|
||||
#define XCHAL_INT20_EXTNUM 15
|
||||
#define XCHAL_INTLEVEL3_VECTOR_PADDR 0x400001C0
|
||||
#define XCHAL_EXTINT7_NUM 9
|
||||
#define XCHAL_EXTINT11_NUM 14
|
||||
#define XCHAL_INT26_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define XCHAL_INT29_TYPE XTHAL_INTTYPE_SOFTWARE
|
||||
#define __FLT32_HAS_QUIET_NAN__ 1
|
||||
#define XCHAL_HAVE_OCD_DIR_ARRAY 0
|
||||
#define __LONG_LONG_MAX__ 0x7fffffffffffffffLL
|
||||
#define XCHAL_HAVE_HIFI3Z 0
|
||||
#define __SIZEOF_SIZE_T__ 4
|
||||
#define XCHAL_XEA_VERSION 2
|
||||
#define XCHAL_DEBUG_VECOFS XCHAL_INTLEVEL6_VECOFS
|
||||
#define __SIZEOF_WINT_T__ 4
|
||||
#define XCHAL_HAVE_FUSIONG_DP_VFPU 0
|
||||
#define XCHAL_INTTYPE_MASK_EXTERN_EDGE 0x50400400
|
||||
#define __LONG_LONG_WIDTH__ 64
|
||||
#define __FLT32_MAX_EXP__ 128
|
||||
#define XCHAL_HAVE_BBENEP 0
|
||||
#define XCHAL_WINDOW_UF12_VECOFS 0x00000140
|
||||
#define XCHAL_EXTINT22_NUM 27
|
||||
#define XCHAL_HAVE_PSO_FULL_RETENTION 0
|
||||
#define __XCHAL_HAVE_MINMAX 1
|
||||
#define __XCHAL_NUM_IBREAK 2
|
||||
#define XCHAL_HAVE_MP_RUNSTALL 0
|
||||
#define XCHAL_INT14_TYPE XTHAL_INTTYPE_NMI
|
||||
#define __GXX_ABI_VERSION 1019
|
||||
#define XCHAL_NUM_DATARAM 1
|
||||
#define __FLT_MIN_EXP__ (-125)
|
||||
#define XCHAL_INT2_EXTNUM 2
|
||||
#define XCHAL_HAVE_DFPU_SINGLE_DOUBLE 0
|
||||
#define XCHAL_HAVE_HIFI4_VFPU 0
|
||||
#define __INT16_MAX__ 0x7fff
|
||||
#define XCHAL_UNALIGNED_STORE_HW 1
|
||||
#define XCHAL_INTLEVEL2_ANDBELOW_MASK 0x003E37FF
|
||||
#define __INT_FAST64_TYPE__ long long int
|
||||
#define XCHAL_RESET_VECBASE_OVERLAP 0
|
||||
#define __FP_FAST_FMAF 1
|
||||
#define __FLT64_DENORM_MIN__ 4.9406564584124654e-324F64
|
||||
#define __DBL_MIN__ ((double)2.2250738585072014e-308L)
|
||||
#define XCHAL_HAVE_FUSION_CONVENC 0
|
||||
#define XCHAL_HAVE_L32R 1
|
||||
#define XCHAL_HAVE_IDMA 0
|
||||
#define XCHAL_ICACHE_WAYS 1
|
||||
#define XCHAL_HW_MAX_VERSION 270012
|
||||
#define __SIZEOF_POINTER__ 4
|
||||
#define XCHAL_RESET_VECTOR0_VADDR 0x50000000
|
||||
#define __SIZE_TYPE__ unsigned int
|
||||
#define XCHAL_VECBASE_RESET_PADDR 0x40000000
|
||||
#define __DBL_HAS_QUIET_NAN__ 1
|
||||
#define __FLT32X_EPSILON__ 2.2204460492503131e-16F32x
|
||||
#define XCHAL_HAVE_PDX16 0
|
||||
#define __XSHAL_HAVE_TEXT_SECTION_LITERALS 1
|
||||
#define XCHAL_HAVE_PRID 1
|
||||
#define XCHAL_ICACHE_LINE_LOCKABLE 0
|
||||
#define XCHAL_HAVE_MUL16 1
|
||||
#define XCHAL_HAVE_CONNXD2 0
|
||||
#define __FLT64_MIN_EXP__ (-1021)
|
||||
#define XCHAL_HAVE_PSO_CDM 0
|
||||
#define XCHAL_HAVE_PIF_WR_RESP 0
|
||||
#define XCHAL_HAVE_SPECULATION 0
|
||||
#define XCHAL_HAVE_MUL32 1
|
||||
#define XCHAL_INT25_EXTNUM 20
|
||||
#define __FLT64_MIN_10_EXP__ (-307)
|
||||
#define XCHAL_DCACHE_LINEWIDTH 4
|
||||
#define XCHAL_DCACHE_ECC_PARITY 0
|
||||
#define XCHAL_INTTYPE_MASK_SOFTWARE 0x20000080
|
||||
#define XCHAL_NUM_INTLEVELS 6
|
||||
#define XCHAL_INT3_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define __REGISTER_PREFIX__
|
||||
#define __UINT16_MAX__ 0xffff
|
||||
#define XCHAL_HAVE_EXCLUSIVE 0
|
||||
#define XCHAL_HAVE_FUSIONG6 0
|
||||
#define __DBL_HAS_DENORM__ 1
|
||||
#define __XSHAL_USE_ABSOLUTE_LITERALS 0
|
||||
#define XCHAL_NUM_TIMERS 3
|
||||
#define __LDBL_HAS_INFINITY__ 1
|
||||
#define XCHAL_INT28_LEVEL 4
|
||||
#define XCHAL_EXTINT21_NUM 26
|
||||
#define XCHAL_EXTINT6_NUM 8
|
||||
#define __FLT32_MIN__ 1.1754943508222875e-38F32
|
||||
#define __UINT8_TYPE__ unsigned char
|
||||
#define XCHAL_NUM_PERF_COUNTERS 2
|
||||
#define XCHAL_DCACHE_ECC_WIDTH 1
|
||||
#define __FLT_DIG__ 6
|
||||
#define __NO_INLINE__ 1
|
||||
#define XCHAL_HAVE_MPU 0
|
||||
#define __DEC_EVAL_METHOD__ 2
|
||||
#define XCHAL_HAVE_BSP3 0
|
||||
#define __FLT_MANT_DIG__ 24
|
||||
#define __LDBL_DECIMAL_DIG__ 17
|
||||
#define XCHAL_INTLEVEL1_MASK 0x000637FF
|
||||
#define __VERSION__ "14.3.0"
|
||||
#define XCHAL_INTLEVEL6_ANDBELOW_MASK 0xFFFFBFFF
|
||||
#define XCHAL_HAVE_FUSIONG3 0
|
||||
#define __UINT64_C(c) c ## ULL
|
||||
#define __XCHAL_NUM_AREGS 64
|
||||
#define XCHAL_PREFETCH_ENTRIES 0
|
||||
#define __XCHAL_HAVE_XEA3 0
|
||||
#define XCHAL_HAVE_BSP3_TRANSPOSE 0
|
||||
#define XCHAL_HAVE_DEPBITS 0
|
||||
#define XCHAL_CLOCK_GATING_FUNCUNIT 1
|
||||
#define XCHAL_HAVE_VECTOR_SELECT 1
|
||||
#define XCHAL_INT23_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define XCHAL_TRAX_MEM_SIZE 16384
|
||||
#define XCHAL_DATARAM0_ECC_PARITY 0
|
||||
#define XCHAL_INT20_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define __GCC_ATOMIC_INT_LOCK_FREE 2
|
||||
#define XCHAL_HAVE_HIFI5_VFPU 0
|
||||
#define __XCHAL_HAVE_DENSITY 1
|
||||
#define XCHAL_INT24_LEVEL 4
|
||||
#define XCHAL_INTLEVEL7_ANDBELOW_MASK 0xFFFFFFFF
|
||||
#define XCHAL_INTTYPE_MASK_IDMA_DONE 0x00000000
|
||||
#define XCHAL_NUM_INTERRUPTS 32
|
||||
#define XCHAL_DOUBLEEXC_VECTOR_PADDR 0x400003C0
|
||||
#define XCHAL_INTLEVEL6_VECTOR_PADDR 0x40000280
|
||||
#define XCHAL_INTLEVEL7_VECOFS XCHAL_NMI_VECOFS
|
||||
#define __FLT32_MANT_DIG__ 24
|
||||
#define __FLOAT_WORD_ORDER__ __ORDER_LITTLE_ENDIAN__
|
||||
#define __XCHAL_HAVE_CLAMPS 0
|
||||
#define XCHAL_INT22_LEVEL 3
|
||||
#define XCHAL_USER_VECOFS 0x00000340
|
||||
#define XCHAL_HAVE_DFP_DIV 0
|
||||
#define __XCHAL_HAVE_DFP_RSQRT 0
|
||||
#define XCHAL_MPU_ALIGN_REQ 1
|
||||
#define __XCHAL_HAVE_NSA 1
|
||||
#define __XCHAL_HAVE_WINDOWED 1
|
||||
#define XCHAL_EXTINT20_NUM 25
|
||||
#define XCHAL_HAVE_USER_SPFPU 0
|
||||
#define XCHAL_HAVE_CACHEATTR 0
|
||||
#define XCHAL_EXTINT5_NUM 5
|
||||
#define __SCHAR_WIDTH__ 8
|
||||
#define XCHAL_KERNEL_VECTOR_VADDR 0x40000300
|
||||
#define __INT32_C(c) c ## L
|
||||
#define __ORDER_PDP_ENDIAN__ 3412
|
||||
#define XCHAL_HAVE_BBE16 0
|
||||
#define XCHAL_DEBUG_VECTOR_PADDR XCHAL_INTLEVEL6_VECTOR_PADDR
|
||||
#define XCHAL_HAVE_FULL_RESET 1
|
||||
#define XCHAL_DCACHE_LINESIZE 16
|
||||
#define __INT_FAST32_TYPE__ int
|
||||
#define XCHAL_EXCM_LEVEL 3
|
||||
#define XCHAL_HAVE_VISION_HISTOGRAM 0
|
||||
#define XCHAL_INT4_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define XCHAL_INT26_LEVEL 5
|
||||
#define XCHAL_HAVE_XLT_CACHEATTR 0
|
||||
#define __UINT_LEAST16_TYPE__ short unsigned int
|
||||
#define XCHAL_HAVE_BBP16 0
|
||||
#define XCHAL_RESET_VECTOR0_PADDR 0x50000000
|
||||
#define XCHAL_INTLEVEL7_VECTOR_PADDR XCHAL_NMI_VECTOR_PADDR
|
||||
#define XCHAL_HAVE_DIV32 1
|
||||
#define XCHAL_HAVE_AXI_ECC 0
|
||||
#define __XCHAL_HAVE_DEBUG 1
|
||||
#define XCHAL_NUM_DATAROM 0
|
||||
#define __UINT64_MAX__ 0xffffffffffffffffULL
|
||||
#define __FLT_IS_IEC_60559__ 1
|
||||
#define XCHAL_DOUBLEEXC_VECTOR_VADDR 0x400003C0
|
||||
#define __GNUC_WIDE_EXECUTION_CHARSET_NAME "UTF-16LE"
|
||||
#define XCHAL_USER_VECTOR_PADDR 0x40000340
|
||||
#define XCHAL_INT23_LEVEL 3
|
||||
#define XCHAL_HAVE_FUSION_SOFTDEMAP 0
|
||||
#define __INT8_TYPE__ signed char
|
||||
#define __ELF__ 1
|
||||
#define XCHAL_HW_REL_LX7_0 1
|
||||
#define XCHAL_INTLEVEL2_MASK 0x00380000
|
||||
#define __XSHAL_ABI 0
|
||||
#define __xtensa__ 1
|
||||
#define XCHAL_DCACHE_SIZE 0
|
||||
#define XCHAL_INT0_LEVEL 1
|
||||
#define __FLT_RADIX__ 2
|
||||
#define __INT_LEAST16_TYPE__ short int
|
||||
#define __LDBL_EPSILON__ 2.2204460492503131e-16L
|
||||
#define __UINTMAX_C(c) c ## ULL
|
||||
#define XCHAL_HAVE_VISIONC 0
|
||||
#define XCHAL_HAVE_BOOLEANS 1
|
||||
#define XCHAL_INT21_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define XCHAL_RESET_VECTOR_VADDR 0x40000400
|
||||
#define __FLT32X_MIN__ 2.2250738585072014e-308F32x
|
||||
#define __XCHAL_HAVE_DFP_SQRT 0
|
||||
#define __SIG_ATOMIC_MAX__ 0x7fffffff
|
||||
#define XCHAL_DATARAM0_PADDR 0x3C000000
|
||||
#define XCHAL_DCACHE_IS_WRITEBACK 0
|
||||
#define __XCHAL_HAVE_MAC16 1
|
||||
#define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2
|
||||
#define __USER_LABEL_PREFIX__
|
||||
#define XCHAL_DCACHE_SETWIDTH 0
|
||||
#define XCHAL_ICACHE_ECC_WIDTH 1
|
||||
#define __SIZEOF_PTRDIFF_T__ 4
|
||||
#define XCHAL_RESET_VECTOR1_VADDR 0x40000400
|
||||
#define __XCHAL_MMU_MIN_PTE_PAGE_SIZE 1
|
||||
#define XCHAL_TIMER1_INTERRUPT 15
|
||||
#define XCHAL_NUM_XLMI 0
|
||||
#define XCHAL_EXTINT4_NUM 4
|
||||
#define XCHAL_HAVE_DCACHE_DYN_WAYS 0
|
||||
#define XCHAL_HAVE_MIMIC_CACHEATTR 1
|
||||
#define __FLT32_HAS_INFINITY__ 1
|
||||
#define XCHAL_NMILEVEL 7
|
||||
#define __SIZEOF_LONG__ 4
|
||||
#define XCHAL_INT10_EXTNUM 8
|
||||
#define __LDBL_DIG__ 15
|
||||
#define __FLT64_IS_IEC_60559__ 1
|
||||
#define __XCHAL_MAX_INSTRUCTION_SIZE 4
|
||||
#define XCHAL_NUM_IBREAK 2
|
||||
#define __FLT32X_MIN_EXP__ (-1021)
|
||||
#define __INT_FAST16_MAX__ 0x7fffffff
|
||||
#define XCHAL_USER_VECTOR_VADDR 0x40000340
|
||||
#define XCHAL_INT24_EXTNUM 19
|
||||
#define XCHAL_INTLEVEL3_ANDBELOW_MASK 0x28FEBFFF
|
||||
#define XCHAL_NUM_MISC_REGS 4
|
||||
#define XCHAL_HAVE_USER_DPFPU 0
|
||||
#define __FLT64_DIG__ 15
|
||||
#define XCHAL_ICACHE_LINESIZE 4
|
||||
#define __UINT_FAST32_MAX__ 0xffffffffU
|
||||
#define __UINT_LEAST64_TYPE__ long long unsigned int
|
||||
#define XCHAL_INSTRAM0_SIZE 67108864
|
||||
#define XCHAL_EXTINT15_NUM 20
|
||||
#define __FLT_HAS_QUIET_NAN__ 1
|
||||
#define __FLT_MAX_10_EXP__ 38
|
||||
#define XCHAL_INT9_LEVEL 1
|
||||
#define __LONG_MAX__ 0x7fffffffL
|
||||
#define XCHAL_INT18_LEVEL 1
|
||||
#define XCHAL_INT5_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define __FLT_HAS_INFINITY__ 1
|
||||
#define __GNUC_EXECUTION_CHARSET_NAME "UTF-8"
|
||||
#define __CHAR_UNSIGNED__ 1
|
||||
#define __UINT_FAST16_TYPE__ unsigned int
|
||||
#define __INT_FAST32_WIDTH__ 32
|
||||
#define __CHAR16_TYPE__ short unsigned int
|
||||
#define __PRAGMA_REDEFINE_EXTNAME 1
|
||||
#define __XCHAL_HAVE_FP_RECIP 1
|
||||
#define XCHAL_HAVE_PDX4 0
|
||||
#define XCHAL_HAVE_PDX8 0
|
||||
#define __SIZE_WIDTH__ 32
|
||||
#define XCHAL_HAVE_DEBUG_APB 0
|
||||
#define XCHAL_INTLEVEL3_VECOFS 0x000001C0
|
||||
#define __INT_LEAST16_MAX__ 0x7fff
|
||||
#define XCHAL_INT7_LEVEL 1
|
||||
#define XCHAL_HAVE_SPANNING_WAY 1
|
||||
#define __INT64_MAX__ 0x7fffffffffffffffLL
|
||||
#define XCHAL_HAVE_VECTORFPU2005 0
|
||||
#define __FLT32_DENORM_MIN__ 1.4012984643248171e-45F32
|
||||
#define __SIG_ATOMIC_WIDTH__ 32
|
||||
#define XCHAL_INTLEVEL3_MASK 0x28C08800
|
||||
#define __INT_LEAST64_TYPE__ long long int
|
||||
#define XCHAL_SW_VERSION 1200012
|
||||
#define __INT16_TYPE__ short int
|
||||
#define __INT_LEAST8_TYPE__ signed char
|
||||
#define XCHAL_HAVE_BBE16_RSQRT 0
|
||||
#define __STDC_VERSION__ 201710L
|
||||
#define XCHAL_SPANNING_WAY 0
|
||||
#define __INT_FAST8_MAX__ 0x7fffffff
|
||||
#define __INTPTR_MAX__ 0x7fffffff
|
||||
#define XCHAL_EXTINT3_NUM 3
|
||||
#define XCHAL_INT17_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define XCHAL_INT5_LEVEL 1
|
||||
#define XCHAL_INT14_LEVEL 7
|
||||
#define XCHAL_HAVE_FP_SQRT 1
|
||||
#define __FLT64_HAS_QUIET_NAN__ 1
|
||||
#define XCHAL_INT22_TYPE XTHAL_INTTYPE_EXTERN_EDGE
|
||||
#define XCHAL_INTLEVEL6_VECOFS 0x00000280
|
||||
#define XCHAL_NUM_AREGS 64
|
||||
#define XCHAL_INT27_LEVEL 3
|
||||
#define XCHAL_HAVE_XEA2 1
|
||||
#define __FLT32_MIN_10_EXP__ (-37)
|
||||
#define XCHAL_HAVE_XEAX 0
|
||||
#define __FLT32X_DIG__ 15
|
||||
#define XCHAL_CA_BITS 4
|
||||
#define __UINT16_C(c) c
|
||||
#define __XCHAL_M_STAGE 2
|
||||
#define XCHAL_HAVE_ICACHE_DYN_WAYS 0
|
||||
#define XCHAL_HAVE_CACHE_BLOCKOPS 0
|
||||
#define __PTRDIFF_WIDTH__ 32
|
||||
#define __LDBL_MANT_DIG__ 53
|
||||
#define _XTENSA_CORE_CONFIGURATION_H
|
||||
#define XCHAL_ICACHE_ECC_PARITY 0
|
||||
#define XCHAL_HAVE_DENSITY 1
|
||||
#define XCHAL_HAVE_HIFI_MINI 0
|
||||
#define XCHAL_INT3_LEVEL 1
|
||||
#define XCHAL_INT12_LEVEL 1
|
||||
#define XCHAL_WINDOW_VECTORS_PADDR 0x40000000
|
||||
#define __FLT64_HAS_INFINITY__ 1
|
||||
#define __SIG_ATOMIC_MIN__ (-__SIG_ATOMIC_MAX__ - 1)
|
||||
#define __XCHAL_ICACHE_SIZE 0
|
||||
#define XCHAL_HAVE_IDMA_TRANSPOSE 0
|
||||
#define __INTPTR_TYPE__ int
|
||||
#define __UINT16_TYPE__ short unsigned int
|
||||
#define __WCHAR_TYPE__ short unsigned int
|
||||
#define __XCHAL_HAVE_DEPBITS 0
|
||||
#define XCHAL_NUM_CONTEXTS 1
|
||||
#define __SIZEOF_FLOAT__ 4
|
||||
#define XCHAL_HAVE_EXTERN_REGS 1
|
||||
#define XCHAL_HAVE_INTERRUPTS 1
|
||||
#define XCHAL_INTTYPE_MASK_NMI 0x00004000
|
||||
#define XCHAL_INT1_LEVEL 1
|
||||
#define XCHAL_HAVE_GRIVPEP 0
|
||||
#define XCHAL_INT10_LEVEL 1
|
||||
#define __UINTPTR_MAX__ 0xffffffffU
|
||||
#define __INT_FAST64_WIDTH__ 64
|
||||
#define XCHAL_HW_CONFIGID_RELIABLE 1
|
||||
#define XCHAL_HAVE_NMI 1
|
||||
#define __FLT32_DECIMAL_DIG__ 9
|
||||
#define XCHAL_HAVE_ICACHE_TEST 0
|
||||
#define XCHAL_HAVE_VISION_SP_VFPU 0
|
||||
#define XCHAL_MPU_ALIGN 0
|
||||
#define __INT_FAST64_MAX__ 0x7fffffffffffffffLL
|
||||
#define XCHAL_HAVE_HIFI5_NN_MAC 0
|
||||
#define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1
|
||||
#define XCHAL_HAVE_DFP_RECIP 0
|
||||
#define __FLT_NORM_MAX__ 3.4028234663852886e+38F
|
||||
#define __XCHAL_HAVE_DFP 0
|
||||
#define __UINT_FAST64_TYPE__ long long unsigned int
|
||||
#define XCHAL_HAVE_SSP16_VITERBI 0
|
||||
#define XCHAL_INT6_TYPE XTHAL_INTTYPE_TIMER
|
||||
#define XCHAL_INTLEVEL4_VECTOR_PADDR 0x40000200
|
||||
#define __INT_MAX__ 0x7fffffff
|
||||
#define __XCHAL_HAVE_EXCLUSIVE 0
|
||||
#define XCHAL_HW_REL_LX7_0_12 1
|
||||
#define XCHAL_INT2_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define XCHAL_HAVE_MP_INTERRUPTS 0
|
||||
#define XCHAL_HAVE_NSA 1
|
||||
#define __INT64_TYPE__ long long int
|
||||
#define __XCHAL_HAVE_DFP_DIV 0
|
||||
#define __FLT_MAX_EXP__ 128
|
||||
#define XCHAL_HAVE_PREDICTED_BRANCHES 0
|
||||
#define XCHAL_INTLEVEL5_VECTOR_PADDR 0x40000240
|
||||
#define __XCHAL_INST_FETCH_WIDTH 4
|
||||
#define XCHAL_HAVE_BE 0
|
||||
#define XCHAL_INT0_EXTNUM 0
|
||||
#define __DBL_MANT_DIG__ 53
|
||||
#define XCHAL_INTLEVEL4_MASK 0x53000000
|
||||
#define XCHAL_HAVE_DEBUG_ERI 1
|
||||
#define XCHAL_HAVE_CP 1
|
||||
#define __INT_LEAST64_MAX__ 0x7fffffffffffffffLL
|
||||
#define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2
|
||||
#define __FP_FAST_FMAF32 1
|
||||
#define XCHAL_HW_CONFIGID0 0xC2F0FFFE
|
||||
#define XCHAL_HW_CONFIGID1 0x23090F1F
|
||||
#define __WINT_TYPE__ unsigned int
|
||||
#define __UINT_LEAST32_TYPE__ long unsigned int
|
||||
#define __SIZEOF_SHORT__ 2
|
||||
#define __FLT32_NORM_MAX__ 3.4028234663852886e+38F32
|
||||
#define XCHAL_WINDOW_OF8_VECOFS 0x00000080
|
||||
#define __LDBL_MIN_EXP__ (-1021)
|
||||
#define __XCHAL_HAVE_S32C1I 1
|
||||
#define XCHAL_NUM_INTERRUPTS_LOG2 5
|
||||
#define XCHAL_PREFETCH_BLOCK_ENTRIES 0
|
||||
#define __FLT64_MAX__ 1.7976931348623157e+308F64
|
||||
#define XCHAL_VISION_QUAD_MAC_TYPE 0
|
||||
#define XCHAL_HAVE_FP 1
|
||||
#define XCHAL_INT18_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define __WINT_WIDTH__ 32
|
||||
#define __INT_LEAST8_MAX__ 0x7f
|
||||
#define __INT_LEAST64_WIDTH__ 64
|
||||
#define XCHAL_INTTYPE_MASK_EXTERN_LEVEL 0x8FBE333F
|
||||
#define __FLT32X_MAX_10_EXP__ 308
|
||||
#define XCHAL_HAVE_DEBUG 1
|
||||
#define __LDBL_MAX_10_EXP__ 308
|
||||
#define __ATOMIC_RELAXED 0
|
||||
#define XCHAL_HAVE_TLBS 1
|
||||
#define XCHAL_INT1_EXTNUM 1
|
||||
#define __DBL_EPSILON__ ((double)2.2204460492503131e-16L)
|
||||
#define __XCHAL_HAVE_SEXT 1
|
||||
#define __INT_LEAST32_TYPE__ long int
|
||||
#define __XTENSA_WINDOWED_ABI__ 1
|
||||
#define XCHAL_MPU_ENTRIES 0
|
||||
#define XCHAL_KERNEL_VECOFS 0x00000300
|
||||
#define __UINT8_C(c) c
|
||||
#define __FLT64_MAX_EXP__ 1024
|
||||
#define XCHAL_HAVE_BBENEP_SP_VFPU 0
|
||||
#define __SIZEOF_WCHAR_T__ 2
|
||||
#define __UINT64_TYPE__ long long unsigned int
|
||||
#define __XCHAL_HAVE_FP_POSTINC 1
|
||||
#define XCHAL_HAVE_MX 0
|
||||
#define XCHAL_UNALIGNED_STORE_EXCEPTION 0
|
||||
#define XCHAL_INT23_EXTNUM 18
|
||||
#define XCHAL_HW_VERSION_MINOR 12
|
||||
#define XCHAL_HW_REL_LX7 1
|
||||
#define __FLT64_NORM_MAX__ 1.7976931348623157e+308F64
|
||||
#define __INTMAX_MAX__ 0x7fffffffffffffffLL
|
||||
#define __INT_FAST8_TYPE__ int
|
||||
#define XCHAL_INT19_EXTNUM 14
|
||||
#define XCHAL_INTLEVEL1_ANDBELOW_MASK 0x000637FF
|
||||
#define XCHAL_EXTINT1_NUM 1
|
||||
#define __XCHAL_HAVE_MUL32_HIGH 1
|
||||
#define __GNUC_STDC_INLINE__ 1
|
||||
#define XCHAL_HAVE_TRAX 1
|
||||
#define __FLT64_HAS_DENORM__ 1
|
||||
#define __FLT32_EPSILON__ 1.1920928955078125e-7F32
|
||||
#define __DBL_DECIMAL_DIG__ 17
|
||||
#define __STDC_UTF_32__ 1
|
||||
#define __XCHAL_HAVE_FP_DIV 1
|
||||
#define __INT_FAST8_WIDTH__ 32
|
||||
#define XCHAL_HAVE_BBE16_VECDIV 0
|
||||
#define XCHAL_HAVE_PSO 0
|
||||
#define XCHAL_INT7_TYPE XTHAL_INTTYPE_SOFTWARE
|
||||
#define __FLT32X_MAX__ 1.7976931348623157e+308F32x
|
||||
#define XCHAL_HAVE_BOOTLOADER 0
|
||||
#define __DBL_NORM_MAX__ ((double)1.7976931348623157e+308L)
|
||||
#define XCHAL_NMI_VECOFS 0x000002C0
|
||||
#define XCHAL_HAVE_S32C1I 1
|
||||
#define XCHAL_ICACHE_SETWIDTH 0
|
||||
#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
|
||||
#define XCHAL_MPU_BG_CACHEADRDIS 0
|
||||
#define XCHAL_INTLEVEL4_ANDBELOW_MASK 0x7BFEBFFF
|
||||
#define XCHAL_INT5_EXTNUM 5
|
||||
#define XCHAL_INT31_LEVEL 5
|
||||
#define XCHAL_NMI_VECTOR_VADDR 0x400002C0
|
||||
#define XCHAL_NUM_AREGS_LOG2 6
|
||||
#define __XTENSA__ 1
|
||||
#define XCHAL_EXTINT18_NUM 23
|
||||
#define __INTMAX_WIDTH__ 64
|
||||
#define __ORDER_BIG_ENDIAN__ 4321
|
||||
#define __XTHAL_ABI_CALL0 1
|
||||
#define XCHAL_HW_MIN_VERSION_MINOR 12
|
||||
#define __FLT32_DIG__ 6
|
||||
#define XCHAL_INSTRAM0_ECC_PARITY 0
|
||||
#define XCHAL_HAVE_FP_RSQRT 1
|
||||
#define __UINT32_C(c) c ## UL
|
||||
#define XCHAL_HAVE_WINDOWED 1
|
||||
#define XCHAL_HW_VERSION_MAJOR 2700
|
||||
#define XCHAL_INTLEVEL5_MASK 0x84010000
|
||||
#define __FLT_DENORM_MIN__ 1.4012984643248171e-45F
|
||||
#define XCHAL_HAVE_MINMAX 1
|
||||
#define XCHAL_HAVE_HIFI3Z_VFPU 0
|
||||
#define XCHAL_TRAX_MEM_SHAREABLE 1
|
||||
#define __INT8_MAX__ 0x7f
|
||||
#define __LONG_WIDTH__ 32
|
||||
#define XCHAL_HAVE_XEA1 0
|
||||
#define XCHAL_HW_MIN_VERSION 270012
|
||||
#define __UINT_FAST32_TYPE__ unsigned int
|
||||
#define XCHAL_LOOP_BUFFER_SIZE 256
|
||||
#define XCHAL_INTLEVEL2_VECTOR_VADDR 0x40000180
|
||||
#define __FLT32X_NORM_MAX__ 1.7976931348623157e+308F32x
|
||||
#define __CHAR32_TYPE__ long unsigned int
|
||||
#define XCHAL_INT19_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define __FLT_MAX__ 3.4028234663852886e+38F
|
||||
#define __XCHAL_UNALIGNED_STORE_EXCEPTION 1
|
||||
#define XCHAL_TRAX_ATB_WIDTH 0
|
||||
#define XCHAL_INTLEVEL7_NUM 14
|
||||
#define XCHAL_DATA_PIPE_DELAY 1
|
||||
#define XCHAL_INT14_EXTNUM 11
|
||||
#define __XCHAL_HAVE_FP_RSQRT 1
|
||||
#define XCHAL_TIMER0_INTERRUPT 6
|
||||
#define XCHAL_HAVE_FUSION_AES 0
|
||||
#define __INT32_TYPE__ long int
|
||||
#define XCHAL_ICACHE_LINEWIDTH 2
|
||||
#define __SIZEOF_DOUBLE__ 8
|
||||
#define __FLT_MIN_10_EXP__ (-37)
|
||||
#define XCHAL_KERNEL_VECTOR_PADDR 0x40000300
|
||||
#define __FLT64_MIN__ 2.2250738585072014e-308F64
|
||||
#define __INT_LEAST32_WIDTH__ 32
|
||||
#define __INTMAX_TYPE__ long long int
|
||||
#define XCHAL_INT28_EXTNUM 23
|
||||
#define __XCHAL_HAVE_ABS 1
|
||||
#define XCHAL_MAX_INSTRUCTION_SIZE 4
|
||||
#define XCHAL_EXTINT0_NUM 0
|
||||
#define XCHAL_INT16_TYPE XTHAL_INTTYPE_TIMER
|
||||
#define XCHAL_HW_MIN_VERSION_MAJOR 2700
|
||||
#define XCHAL_INSTRAM0_VADDR 0x40000000
|
||||
#define __FLT32X_HAS_QUIET_NAN__ 1
|
||||
#define __ATOMIC_CONSUME 1
|
||||
#define XCHAL_HAVE_IDENTITY_MAP 1
|
||||
#define __XCHAL_NUM_DBREAK 2
|
||||
#define __XCHAL_HAVE_WIDE_BRANCHES 0
|
||||
#define __GNUC_MINOR__ 3
|
||||
#define __INT_FAST16_WIDTH__ 32
|
||||
#define __UINTMAX_MAX__ 0xffffffffffffffffULL
|
||||
#define __FLT32X_DENORM_MIN__ 4.9406564584124654e-324F32x
|
||||
#define XCHAL_HAVE_FUSION_FP 0
|
||||
#define XCHAL_HAVE_FUSIONG 0
|
||||
#define XCHAL_INTTYPE_MASK_IDMA_ERR 0x00000000
|
||||
#define __DBL_MAX_10_EXP__ 308
|
||||
#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324L
|
||||
#define XCHAL_HAVE_DEBUG_JTAG 1
|
||||
#define XCHAL_TRAX_TIME_WIDTH 0
|
||||
#define __INT16_C(c) c
|
||||
#define __ATOMIC_RELEASE 3
|
||||
#define XCHAL_WINDOW_OF4_VECOFS 0x00000000
|
||||
#define XCHAL_INTLEVEL3_VECTOR_VADDR 0x400001C0
|
||||
#define __STDC__ 1
|
||||
#define XCHAL_EXTINT17_NUM 22
|
||||
#define __PTRDIFF_TYPE__ int
|
||||
#define XCHAL_INT26_EXTNUM 21
|
||||
#define XCHAL_HAVE_VECTRALX 0
|
||||
#define XCHAL_HAVE_HALT 0
|
||||
#define XCHAL_UNALIGNED_LOAD_HW 1
|
||||
#define XCHAL_HAVE_CCOUNT 1
|
||||
#define XCHAL_INT8_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
#define __XCHAL_HAVE_FP_SQRT 1
|
||||
#define __UINT32_TYPE__ long unsigned int
|
||||
#define __FLT32X_MIN_10_EXP__ (-307)
|
||||
#define __UINTPTR_TYPE__ unsigned int
|
||||
#define XCHAL_HAVE_FUSION_BITOPS 0
|
||||
#define __LDBL_MIN_10_EXP__ (-307)
|
||||
#define XCHAL_EXTINT2_NUM 2
|
||||
#define XCHAL_INT29_LEVEL 3
|
||||
#define __SIZEOF_LONG_LONG__ 8
|
||||
#define XCHAL_FUSIONG_SIMD32 0
|
||||
#define XCHAL_INTLEVEL2_VECOFS 0x00000180
|
||||
#define XCHAL_HAVE_FUSION_16BIT_BASEBAND 0
|
||||
#define XCHAL_INT31_EXTNUM 25
|
||||
#define __GCC_ATOMIC_LLONG_LOCK_FREE 1
|
||||
#define XCHAL_HAVE_DFP_SQRT 0
|
||||
#define XCHAL_INTTYPE_MASK_WRITE_ERROR 0x00000000
|
||||
#define XCHAL_HAVE_FUSION_AVS 0
|
||||
#define XCHAL_HAVE_HIFI2EP 0
|
||||
#define XCHAL_EXTINT19_NUM 24
|
||||
#define __XCHAL_UNALIGNED_LOAD_EXCEPTION 1
|
||||
#define __FLT_DECIMAL_DIG__ 9
|
||||
#define __UINT_FAST16_MAX__ 0xffffffffU
|
||||
#define XCHAL_HAVE_DFP 0
|
||||
#define __LDBL_NORM_MAX__ 1.7976931348623157e+308L
|
||||
#define XCHAL_HAVE_OCD 1
|
||||
#define __GCC_ATOMIC_SHORT_LOCK_FREE 2
|
||||
#define XCHAL_HAVE_WIDE_BRANCHES 0
|
||||
#define __XCHAL_HAVE_BE 0
|
||||
#define __UINT_FAST8_TYPE__ unsigned int
|
||||
#define XCHAL_HAVE_HIFI2 0
|
||||
#define XCHAL_HAVE_HIFI3 0
|
||||
#define XCHAL_HAVE_HIFI4 0
|
||||
#define XCHAL_HAVE_HIFI5 0
|
||||
#define XCHAL_INTLEVEL4_VECTOR_VADDR 0x40000200
|
||||
#define XCHAL_HAVE_PREFETCH_L1 0
|
||||
#define XCHAL_HAVE_HIFIPRO 0
|
||||
#define __ATOMIC_ACQ_REL 4
|
||||
#define XCHAL_INT25_TYPE XTHAL_INTTYPE_EXTERN_LEVEL
|
||||
15324
build/zephyr/include/generated/zephyr/devicetree_generated.h
Normal file
15324
build/zephyr/include/generated/zephyr/devicetree_generated.h
Normal file
File diff suppressed because one or more lines are too long
190
build/zephyr/include/generated/zephyr/driver-validation.h
Normal file
190
build/zephyr/include/generated/zephyr/driver-validation.h
Normal file
@@ -0,0 +1,190 @@
|
||||
#ifndef DRIVER_VALIDATION_GEN_H
|
||||
#define DRIVER_VALIDATION_GEN_H
|
||||
#define K_SYSCALL_DRIVER_GEN(ptr, op, driver_lower_case, driver_upper_case) \
|
||||
(K_SYSCALL_OBJ(ptr, K_OBJ_DRIVER_##driver_upper_case) || \
|
||||
K_SYSCALL_DRIVER_OP(ptr, driver_lower_case##_driver_api, op))
|
||||
|
||||
#define K_SYSCALL_DRIVER_GPIO(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, gpio, GPIO)
|
||||
|
||||
#define K_SYSCALL_DRIVER_SPI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, spi, SPI)
|
||||
|
||||
#define K_SYSCALL_DRIVER_SHARED_IRQ(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, shared_irq, SHARED_IRQ)
|
||||
|
||||
#define K_SYSCALL_DRIVER_CRYPTO(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, crypto, CRYPTO)
|
||||
|
||||
#define K_SYSCALL_DRIVER_ADC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, adc, ADC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_AUXDISPLAY(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, auxdisplay, AUXDISPLAY)
|
||||
|
||||
#define K_SYSCALL_DRIVER_BBRAM(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, bbram, BBRAM)
|
||||
|
||||
#define K_SYSCALL_DRIVER_BIOMETRIC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, biometric, BIOMETRIC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_BT_HCI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, bt_hci, BT_HCI)
|
||||
|
||||
#define K_SYSCALL_DRIVER_CAN(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, can, CAN)
|
||||
|
||||
#define K_SYSCALL_DRIVER_CELLULAR(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, cellular, CELLULAR)
|
||||
|
||||
#define K_SYSCALL_DRIVER_CHARGER(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, charger, CHARGER)
|
||||
|
||||
#define K_SYSCALL_DRIVER_CLOCK_CONTROL(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, clock_control, CLOCK_CONTROL)
|
||||
|
||||
#define K_SYSCALL_DRIVER_COMPARATOR(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, comparator, COMPARATOR)
|
||||
|
||||
#define K_SYSCALL_DRIVER_COREDUMP(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, coredump, COREDUMP)
|
||||
|
||||
#define K_SYSCALL_DRIVER_COUNTER(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, counter, COUNTER)
|
||||
|
||||
#define K_SYSCALL_DRIVER_CRC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, crc, CRC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_DAC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, dac, DAC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_DAI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, dai, DAI)
|
||||
|
||||
#define K_SYSCALL_DRIVER_DISPLAY(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, display, DISPLAY)
|
||||
|
||||
#define K_SYSCALL_DRIVER_DMA(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, dma, DMA)
|
||||
|
||||
#define K_SYSCALL_DRIVER_EDAC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, edac, EDAC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_EEPROM(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, eeprom, EEPROM)
|
||||
|
||||
#define K_SYSCALL_DRIVER_EMUL_BBRAM(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, emul_bbram, EMUL_BBRAM)
|
||||
|
||||
#define K_SYSCALL_DRIVER_FUEL_GAUGE_EMUL(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, fuel_gauge_emul, FUEL_GAUGE_EMUL)
|
||||
|
||||
#define K_SYSCALL_DRIVER_EMUL_SENSOR(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, emul_sensor, EMUL_SENSOR)
|
||||
|
||||
#define K_SYSCALL_DRIVER_ENTROPY(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, entropy, ENTROPY)
|
||||
|
||||
#define K_SYSCALL_DRIVER_ESPI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, espi, ESPI)
|
||||
|
||||
#define K_SYSCALL_DRIVER_ESPI_SAF(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, espi_saf, ESPI_SAF)
|
||||
|
||||
#define K_SYSCALL_DRIVER_FLASH(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, flash, FLASH)
|
||||
|
||||
#define K_SYSCALL_DRIVER_FPGA(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, fpga, FPGA)
|
||||
|
||||
#define K_SYSCALL_DRIVER_FUEL_GAUGE(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, fuel_gauge, FUEL_GAUGE)
|
||||
|
||||
#define K_SYSCALL_DRIVER_GNSS(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, gnss, GNSS)
|
||||
|
||||
#define K_SYSCALL_DRIVER_HAPTICS(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, haptics, HAPTICS)
|
||||
|
||||
#define K_SYSCALL_DRIVER_HWSPINLOCK(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, hwspinlock, HWSPINLOCK)
|
||||
|
||||
#define K_SYSCALL_DRIVER_I2C(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, i2c, I2C)
|
||||
|
||||
#define K_SYSCALL_DRIVER_I2C_TARGET(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, i2c_target, I2C_TARGET)
|
||||
|
||||
#define K_SYSCALL_DRIVER_I2S(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, i2s, I2S)
|
||||
|
||||
#define K_SYSCALL_DRIVER_I3C(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, i3c, I3C)
|
||||
|
||||
#define K_SYSCALL_DRIVER_IPM(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, ipm, IPM)
|
||||
|
||||
#define K_SYSCALL_DRIVER_LED(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, led, LED)
|
||||
|
||||
#define K_SYSCALL_DRIVER_LED_STRIP(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, led_strip, LED_STRIP)
|
||||
|
||||
#define K_SYSCALL_DRIVER_LORA(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, lora, LORA)
|
||||
|
||||
#define K_SYSCALL_DRIVER_MBOX(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, mbox, MBOX)
|
||||
|
||||
#define K_SYSCALL_DRIVER_MDIO(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, mdio, MDIO)
|
||||
|
||||
#define K_SYSCALL_DRIVER_MIPI_DBI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, mipi_dbi, MIPI_DBI)
|
||||
|
||||
#define K_SYSCALL_DRIVER_MIPI_DSI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, mipi_dsi, MIPI_DSI)
|
||||
|
||||
#define K_SYSCALL_DRIVER_MSPI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, mspi, MSPI)
|
||||
|
||||
#define K_SYSCALL_DRIVER_OPAMP(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, opamp, OPAMP)
|
||||
|
||||
#define K_SYSCALL_DRIVER_OTP(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, otp, OTP)
|
||||
|
||||
#define K_SYSCALL_DRIVER_PECI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, peci, PECI)
|
||||
|
||||
#define K_SYSCALL_DRIVER_PS2(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, ps2, PS2)
|
||||
|
||||
#define K_SYSCALL_DRIVER_PTP_CLOCK(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, ptp_clock, PTP_CLOCK)
|
||||
|
||||
#define K_SYSCALL_DRIVER_PWM(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, pwm, PWM)
|
||||
|
||||
#define K_SYSCALL_DRIVER_REGULATOR_PARENT(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, regulator_parent, REGULATOR_PARENT)
|
||||
|
||||
#define K_SYSCALL_DRIVER_REGULATOR(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, regulator, REGULATOR)
|
||||
|
||||
#define K_SYSCALL_DRIVER_RESET(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, reset, RESET)
|
||||
|
||||
#define K_SYSCALL_DRIVER_RETAINED_MEM(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, retained_mem, RETAINED_MEM)
|
||||
|
||||
#define K_SYSCALL_DRIVER_RTC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, rtc, RTC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_SDHC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, sdhc, SDHC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_SENSOR(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, sensor, SENSOR)
|
||||
|
||||
#define K_SYSCALL_DRIVER_SMBUS(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, smbus, SMBUS)
|
||||
|
||||
#define K_SYSCALL_DRIVER_SYSCON(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, syscon, SYSCON)
|
||||
|
||||
#define K_SYSCALL_DRIVER_TEE(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, tee, TEE)
|
||||
|
||||
#define K_SYSCALL_DRIVER_UAOL(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, uaol, UAOL)
|
||||
|
||||
#define K_SYSCALL_DRIVER_VIDEO(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, video, VIDEO)
|
||||
|
||||
#define K_SYSCALL_DRIVER_VIRTIO(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, virtio, VIRTIO)
|
||||
|
||||
#define K_SYSCALL_DRIVER_W1(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, w1, W1)
|
||||
|
||||
#define K_SYSCALL_DRIVER_WDT(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, wdt, WDT)
|
||||
|
||||
#define K_SYSCALL_DRIVER_WUC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, wuc, WUC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_CAN_TRANSCEIVER(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, can_transceiver, CAN_TRANSCEIVER)
|
||||
|
||||
#define K_SYSCALL_DRIVER_NRF_CLOCK_CONTROL(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, nrf_clock_control, NRF_CLOCK_CONTROL)
|
||||
|
||||
#define K_SYSCALL_DRIVER_I3C_TARGET(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, i3c_target, I3C_TARGET)
|
||||
|
||||
#define K_SYSCALL_DRIVER_ITS(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, its, ITS)
|
||||
|
||||
#define K_SYSCALL_DRIVER_VTD(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, vtd, VTD)
|
||||
|
||||
#define K_SYSCALL_DRIVER_RENESAS_ELC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, renesas_elc, RENESAS_ELC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_TGPIO(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, tgpio, TGPIO)
|
||||
|
||||
#define K_SYSCALL_DRIVER_PCIE_CTRL(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, pcie_ctrl, PCIE_CTRL)
|
||||
|
||||
#define K_SYSCALL_DRIVER_PCIE_EP(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, pcie_ep, PCIE_EP)
|
||||
|
||||
#define K_SYSCALL_DRIVER_PSI5(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, psi5, PSI5)
|
||||
|
||||
#define K_SYSCALL_DRIVER_SENT(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, sent, SENT)
|
||||
|
||||
#define K_SYSCALL_DRIVER_SVC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, svc, SVC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_STEPPER(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, stepper, STEPPER)
|
||||
|
||||
#define K_SYSCALL_DRIVER_STEPPER_CTRL(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, stepper_ctrl, STEPPER_CTRL)
|
||||
|
||||
#define K_SYSCALL_DRIVER_UART(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, uart, UART)
|
||||
|
||||
#define K_SYSCALL_DRIVER_BC12_EMUL(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, bc12_emul, BC12_EMUL)
|
||||
|
||||
#define K_SYSCALL_DRIVER_BC12(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, bc12, BC12)
|
||||
|
||||
#define K_SYSCALL_DRIVER_USBC_PPC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, usbc_ppc, USBC_PPC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_TCPC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, tcpc, TCPC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_USBC_VBUS(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, usbc_vbus, USBC_VBUS)
|
||||
|
||||
#define K_SYSCALL_DRIVER_IVSHMEM(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, ivshmem, IVSHMEM)
|
||||
|
||||
#define K_SYSCALL_DRIVER_ETHPHY(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, ethphy, ETHPHY)
|
||||
#endif /* DRIVER_VALIDATION_GEN_H */
|
||||
19
build/zephyr/include/generated/zephyr/heap_constants.h
Normal file
19
build/zephyr/include/generated/zephyr/heap_constants.h
Normal file
@@ -0,0 +1,19 @@
|
||||
/* THIS FILE IS AUTO GENERATED. PLEASE DO NOT EDIT.
|
||||
*
|
||||
* This header file provides macros for the offsets of various structure
|
||||
* members. These offset macros are primarily intended to be used in
|
||||
* assembly code.
|
||||
*/
|
||||
|
||||
#ifndef __GEN_HEAP_CONSTANTS_H__
|
||||
#define __GEN_HEAP_CONSTANTS_H__
|
||||
|
||||
#define ___z_heap_struct_SIZEOF 0x10
|
||||
#define ___z_heap_bucket_SIZEOF 0x4
|
||||
#define ___z_heap_chunk_unit_SIZEOF 0x8
|
||||
#define ___z_heap_hdr_SIZEOF 0x4
|
||||
#define ___z_heap_ftr_SIZEOF 0x4
|
||||
#define ___z_heap_trailer_SIZEOF 0x0
|
||||
#define ___z_heap_min_chunk_SIZEOF 0x1
|
||||
|
||||
#endif /* __GEN_HEAP_CONSTANTS_H__ */
|
||||
140
build/zephyr/include/generated/zephyr/kobj-types-enum.h
Normal file
140
build/zephyr/include/generated/zephyr/kobj-types-enum.h
Normal file
@@ -0,0 +1,140 @@
|
||||
/* Core kernel objects */
|
||||
K_OBJ_MEM_SLAB,
|
||||
K_OBJ_MSGQ,
|
||||
K_OBJ_MUTEX,
|
||||
K_OBJ_PIPE,
|
||||
K_OBJ_QUEUE,
|
||||
K_OBJ_POLL_SIGNAL,
|
||||
K_OBJ_SEM,
|
||||
K_OBJ_STACK,
|
||||
K_OBJ_THREAD,
|
||||
K_OBJ_TIMER,
|
||||
K_OBJ_THREAD_STACK_ELEMENT,
|
||||
K_OBJ_NET_SOCKET,
|
||||
K_OBJ_NET_IF,
|
||||
K_OBJ_SYS_MUTEX,
|
||||
K_OBJ_FUTEX,
|
||||
K_OBJ_CONDVAR,
|
||||
#ifdef CONFIG_EVENTS
|
||||
K_OBJ_EVENT,
|
||||
#endif
|
||||
#ifdef CONFIG_ZTEST
|
||||
K_OBJ_ZTEST_SUITE_NODE,
|
||||
#endif
|
||||
#ifdef CONFIG_ZTEST
|
||||
K_OBJ_ZTEST_SUITE_STATS,
|
||||
#endif
|
||||
#ifdef CONFIG_ZTEST
|
||||
K_OBJ_ZTEST_UNIT_TEST,
|
||||
#endif
|
||||
#ifdef CONFIG_ZTEST
|
||||
K_OBJ_ZTEST_TEST_RULE,
|
||||
#endif
|
||||
#ifdef CONFIG_RTIO
|
||||
K_OBJ_RTIO,
|
||||
#endif
|
||||
#ifdef CONFIG_RTIO
|
||||
K_OBJ_RTIO_IODEV,
|
||||
#endif
|
||||
#ifdef CONFIG_RTIO
|
||||
K_OBJ_RTIO_POOL,
|
||||
#endif
|
||||
#ifdef CONFIG_ADC_STREAM
|
||||
K_OBJ_ADC_DECODER_API,
|
||||
#endif
|
||||
#ifdef CONFIG_SENSOR_ASYNC_API
|
||||
K_OBJ_SENSOR_DECODER_API,
|
||||
#endif
|
||||
/* Driver subsystems */
|
||||
K_OBJ_DRIVER_GPIO,
|
||||
K_OBJ_DRIVER_SPI,
|
||||
K_OBJ_DRIVER_SHARED_IRQ,
|
||||
K_OBJ_DRIVER_CRYPTO,
|
||||
K_OBJ_DRIVER_ADC,
|
||||
K_OBJ_DRIVER_AUXDISPLAY,
|
||||
K_OBJ_DRIVER_BBRAM,
|
||||
K_OBJ_DRIVER_BIOMETRIC,
|
||||
K_OBJ_DRIVER_BT_HCI,
|
||||
K_OBJ_DRIVER_CAN,
|
||||
K_OBJ_DRIVER_CELLULAR,
|
||||
K_OBJ_DRIVER_CHARGER,
|
||||
K_OBJ_DRIVER_CLOCK_CONTROL,
|
||||
K_OBJ_DRIVER_COMPARATOR,
|
||||
K_OBJ_DRIVER_COREDUMP,
|
||||
K_OBJ_DRIVER_COUNTER,
|
||||
K_OBJ_DRIVER_CRC,
|
||||
K_OBJ_DRIVER_DAC,
|
||||
K_OBJ_DRIVER_DAI,
|
||||
K_OBJ_DRIVER_DISPLAY,
|
||||
K_OBJ_DRIVER_DMA,
|
||||
K_OBJ_DRIVER_EDAC,
|
||||
K_OBJ_DRIVER_EEPROM,
|
||||
K_OBJ_DRIVER_EMUL_BBRAM,
|
||||
K_OBJ_DRIVER_FUEL_GAUGE_EMUL,
|
||||
K_OBJ_DRIVER_EMUL_SENSOR,
|
||||
K_OBJ_DRIVER_ENTROPY,
|
||||
K_OBJ_DRIVER_ESPI,
|
||||
K_OBJ_DRIVER_ESPI_SAF,
|
||||
K_OBJ_DRIVER_FLASH,
|
||||
K_OBJ_DRIVER_FPGA,
|
||||
K_OBJ_DRIVER_FUEL_GAUGE,
|
||||
K_OBJ_DRIVER_GNSS,
|
||||
K_OBJ_DRIVER_HAPTICS,
|
||||
K_OBJ_DRIVER_HWSPINLOCK,
|
||||
K_OBJ_DRIVER_I2C,
|
||||
K_OBJ_DRIVER_I2C_TARGET,
|
||||
K_OBJ_DRIVER_I2S,
|
||||
K_OBJ_DRIVER_I3C,
|
||||
K_OBJ_DRIVER_IPM,
|
||||
K_OBJ_DRIVER_LED,
|
||||
K_OBJ_DRIVER_LED_STRIP,
|
||||
K_OBJ_DRIVER_LORA,
|
||||
K_OBJ_DRIVER_MBOX,
|
||||
K_OBJ_DRIVER_MDIO,
|
||||
K_OBJ_DRIVER_MIPI_DBI,
|
||||
K_OBJ_DRIVER_MIPI_DSI,
|
||||
K_OBJ_DRIVER_MSPI,
|
||||
K_OBJ_DRIVER_OPAMP,
|
||||
K_OBJ_DRIVER_OTP,
|
||||
K_OBJ_DRIVER_PECI,
|
||||
K_OBJ_DRIVER_PS2,
|
||||
K_OBJ_DRIVER_PTP_CLOCK,
|
||||
K_OBJ_DRIVER_PWM,
|
||||
K_OBJ_DRIVER_REGULATOR_PARENT,
|
||||
K_OBJ_DRIVER_REGULATOR,
|
||||
K_OBJ_DRIVER_RESET,
|
||||
K_OBJ_DRIVER_RETAINED_MEM,
|
||||
K_OBJ_DRIVER_RTC,
|
||||
K_OBJ_DRIVER_SDHC,
|
||||
K_OBJ_DRIVER_SENSOR,
|
||||
K_OBJ_DRIVER_SMBUS,
|
||||
K_OBJ_DRIVER_SYSCON,
|
||||
K_OBJ_DRIVER_TEE,
|
||||
K_OBJ_DRIVER_UAOL,
|
||||
K_OBJ_DRIVER_VIDEO,
|
||||
K_OBJ_DRIVER_VIRTIO,
|
||||
K_OBJ_DRIVER_W1,
|
||||
K_OBJ_DRIVER_WDT,
|
||||
K_OBJ_DRIVER_WUC,
|
||||
K_OBJ_DRIVER_CAN_TRANSCEIVER,
|
||||
K_OBJ_DRIVER_NRF_CLOCK_CONTROL,
|
||||
K_OBJ_DRIVER_I3C_TARGET,
|
||||
K_OBJ_DRIVER_ITS,
|
||||
K_OBJ_DRIVER_VTD,
|
||||
K_OBJ_DRIVER_RENESAS_ELC,
|
||||
K_OBJ_DRIVER_TGPIO,
|
||||
K_OBJ_DRIVER_PCIE_CTRL,
|
||||
K_OBJ_DRIVER_PCIE_EP,
|
||||
K_OBJ_DRIVER_PSI5,
|
||||
K_OBJ_DRIVER_SENT,
|
||||
K_OBJ_DRIVER_SVC,
|
||||
K_OBJ_DRIVER_STEPPER,
|
||||
K_OBJ_DRIVER_STEPPER_CTRL,
|
||||
K_OBJ_DRIVER_UART,
|
||||
K_OBJ_DRIVER_BC12_EMUL,
|
||||
K_OBJ_DRIVER_BC12,
|
||||
K_OBJ_DRIVER_USBC_PPC,
|
||||
K_OBJ_DRIVER_TCPC,
|
||||
K_OBJ_DRIVER_USBC_VBUS,
|
||||
K_OBJ_DRIVER_IVSHMEM,
|
||||
K_OBJ_DRIVER_ETHPHY,
|
||||
48
build/zephyr/include/generated/zephyr/offsets.h
Normal file
48
build/zephyr/include/generated/zephyr/offsets.h
Normal file
@@ -0,0 +1,48 @@
|
||||
/* THIS FILE IS AUTO GENERATED. PLEASE DO NOT EDIT.
|
||||
*
|
||||
* This header file provides macros for the offsets of various structure
|
||||
* members. These offset macros are primarily intended to be used in
|
||||
* assembly code.
|
||||
*/
|
||||
|
||||
#ifndef __GEN_OFFSETS_H__
|
||||
#define __GEN_OFFSETS_H__
|
||||
|
||||
#define ___cpu_t_current_OFFSET 0x8
|
||||
#define ___cpu_t_nested_OFFSET 0x0
|
||||
#define ___cpu_t_irq_stack_OFFSET 0x4
|
||||
#define ___cpu_t_arch_OFFSET 0x11
|
||||
#define ___kernel_t_cpus_OFFSET 0x0
|
||||
#define ___kernel_t_ready_q_OFFSET 0x14
|
||||
#define ___ready_q_t_cache_OFFSET 0x0
|
||||
#define ___thread_base_t_user_options_OFFSET 0xc
|
||||
#define ___thread_t_base_OFFSET 0x0
|
||||
#define ___thread_t_callee_saved_OFFSET 0x30
|
||||
#define ___thread_t_arch_OFFSET 0x60
|
||||
#define ___thread_t_switch_handle_OFFSET 0x58
|
||||
#define ___thread_t_stack_info_OFFSET 0x48
|
||||
#define __z_interrupt_stack_SIZEOF 0x800
|
||||
#define __z_interrupt_all_stacks_SIZEOF 0x800
|
||||
#define _PM_DEVICE_STRUCT_FLAGS_OFFSET 0x0
|
||||
#define ___xtensa_irq_bsa_t_SIZEOF 0x4c
|
||||
#define ___xtensa_irq_stack_frame_raw_t_SIZEOF 0x34
|
||||
#define ___xtensa_irq_stack_frame_a15_t_SIZEOF 0x80
|
||||
#define ___xtensa_irq_stack_frame_a11_t_SIZEOF 0x70
|
||||
#define ___xtensa_irq_stack_frame_a7_t_SIZEOF 0x60
|
||||
#define ___xtensa_irq_stack_frame_a3_t_SIZEOF 0x50
|
||||
#define ___xtensa_irq_bsa_t_a0_OFFSET 0x28
|
||||
#define ___xtensa_irq_bsa_t_scratch_OFFSET 0x2c
|
||||
#define ___xtensa_irq_bsa_t_a2_OFFSET 0x30
|
||||
#define ___xtensa_irq_bsa_t_a3_OFFSET 0x34
|
||||
#define ___xtensa_irq_bsa_t_exccause_OFFSET 0x8
|
||||
#define ___xtensa_irq_bsa_t_excvaddr_OFFSET 0xc
|
||||
#define ___xtensa_irq_bsa_t_pc_OFFSET 0x24
|
||||
#define ___xtensa_irq_bsa_t_ps_OFFSET 0x20
|
||||
#define ___xtensa_irq_bsa_t_sar_OFFSET 0x1c
|
||||
#define ___xtensa_irq_bsa_t_lcount_OFFSET 0x10
|
||||
#define ___xtensa_irq_bsa_t_lbeg_OFFSET 0x18
|
||||
#define ___xtensa_irq_bsa_t_lend_OFFSET 0x14
|
||||
#define ___xtensa_irq_bsa_t_scompare1_OFFSET 0x4
|
||||
#define ___xtensa_irq_bsa_t_threadptr_OFFSET 0x0
|
||||
|
||||
#endif /* __GEN_OFFSETS_H__ */
|
||||
15
build/zephyr/include/generated/zephyr/otype-to-size.h
Normal file
15
build/zephyr/include/generated/zephyr/otype-to-size.h
Normal file
@@ -0,0 +1,15 @@
|
||||
/* Non device/stack objects */
|
||||
case K_OBJ_MEM_SLAB: ret = sizeof(struct k_mem_slab); break;
|
||||
case K_OBJ_MSGQ: ret = sizeof(struct k_msgq); break;
|
||||
case K_OBJ_MUTEX: ret = sizeof(struct k_mutex); break;
|
||||
case K_OBJ_PIPE: ret = sizeof(struct k_pipe); break;
|
||||
case K_OBJ_QUEUE: ret = sizeof(struct k_queue); break;
|
||||
case K_OBJ_POLL_SIGNAL: ret = sizeof(struct k_poll_signal); break;
|
||||
case K_OBJ_SEM: ret = sizeof(struct k_sem); break;
|
||||
case K_OBJ_STACK: ret = sizeof(struct k_stack); break;
|
||||
case K_OBJ_THREAD: ret = sizeof(struct k_thread); break;
|
||||
case K_OBJ_TIMER: ret = sizeof(struct k_timer); break;
|
||||
case K_OBJ_CONDVAR: ret = sizeof(struct k_condvar); break;
|
||||
#ifdef CONFIG_EVENTS
|
||||
case K_OBJ_EVENT: ret = sizeof(struct k_event); break;
|
||||
#endif
|
||||
140
build/zephyr/include/generated/zephyr/otype-to-str.h
Normal file
140
build/zephyr/include/generated/zephyr/otype-to-str.h
Normal file
@@ -0,0 +1,140 @@
|
||||
/* Core kernel objects */
|
||||
case K_OBJ_MEM_SLAB: ret = "k_mem_slab"; break;
|
||||
case K_OBJ_MSGQ: ret = "k_msgq"; break;
|
||||
case K_OBJ_MUTEX: ret = "k_mutex"; break;
|
||||
case K_OBJ_PIPE: ret = "k_pipe"; break;
|
||||
case K_OBJ_QUEUE: ret = "k_queue"; break;
|
||||
case K_OBJ_POLL_SIGNAL: ret = "k_poll_signal"; break;
|
||||
case K_OBJ_SEM: ret = "k_sem"; break;
|
||||
case K_OBJ_STACK: ret = "k_stack"; break;
|
||||
case K_OBJ_THREAD: ret = "k_thread"; break;
|
||||
case K_OBJ_TIMER: ret = "k_timer"; break;
|
||||
case K_OBJ_THREAD_STACK_ELEMENT: ret = "z_thread_stack_element"; break;
|
||||
case K_OBJ_NET_SOCKET: ret = "NET_SOCKET"; break;
|
||||
case K_OBJ_NET_IF: ret = "net_if"; break;
|
||||
case K_OBJ_SYS_MUTEX: ret = "sys_mutex"; break;
|
||||
case K_OBJ_FUTEX: ret = "k_futex"; break;
|
||||
case K_OBJ_CONDVAR: ret = "k_condvar"; break;
|
||||
#ifdef CONFIG_EVENTS
|
||||
case K_OBJ_EVENT: ret = "k_event"; break;
|
||||
#endif
|
||||
#ifdef CONFIG_ZTEST
|
||||
case K_OBJ_ZTEST_SUITE_NODE: ret = "ztest_suite_node"; break;
|
||||
#endif
|
||||
#ifdef CONFIG_ZTEST
|
||||
case K_OBJ_ZTEST_SUITE_STATS: ret = "ztest_suite_stats"; break;
|
||||
#endif
|
||||
#ifdef CONFIG_ZTEST
|
||||
case K_OBJ_ZTEST_UNIT_TEST: ret = "ztest_unit_test"; break;
|
||||
#endif
|
||||
#ifdef CONFIG_ZTEST
|
||||
case K_OBJ_ZTEST_TEST_RULE: ret = "ztest_test_rule"; break;
|
||||
#endif
|
||||
#ifdef CONFIG_RTIO
|
||||
case K_OBJ_RTIO: ret = "rtio"; break;
|
||||
#endif
|
||||
#ifdef CONFIG_RTIO
|
||||
case K_OBJ_RTIO_IODEV: ret = "rtio_iodev"; break;
|
||||
#endif
|
||||
#ifdef CONFIG_RTIO
|
||||
case K_OBJ_RTIO_POOL: ret = "rtio_pool"; break;
|
||||
#endif
|
||||
#ifdef CONFIG_ADC_STREAM
|
||||
case K_OBJ_ADC_DECODER_API: ret = "adc_decoder_api"; break;
|
||||
#endif
|
||||
#ifdef CONFIG_SENSOR_ASYNC_API
|
||||
case K_OBJ_SENSOR_DECODER_API: ret = "sensor_decoder_api"; break;
|
||||
#endif
|
||||
/* Driver subsystems */
|
||||
case K_OBJ_DRIVER_GPIO: ret = "gpio driver"; break;
|
||||
case K_OBJ_DRIVER_SPI: ret = "spi driver"; break;
|
||||
case K_OBJ_DRIVER_SHARED_IRQ: ret = "shared_irq driver"; break;
|
||||
case K_OBJ_DRIVER_CRYPTO: ret = "crypto driver"; break;
|
||||
case K_OBJ_DRIVER_ADC: ret = "adc driver"; break;
|
||||
case K_OBJ_DRIVER_AUXDISPLAY: ret = "auxdisplay driver"; break;
|
||||
case K_OBJ_DRIVER_BBRAM: ret = "bbram driver"; break;
|
||||
case K_OBJ_DRIVER_BIOMETRIC: ret = "biometric driver"; break;
|
||||
case K_OBJ_DRIVER_BT_HCI: ret = "bt_hci driver"; break;
|
||||
case K_OBJ_DRIVER_CAN: ret = "can driver"; break;
|
||||
case K_OBJ_DRIVER_CELLULAR: ret = "cellular driver"; break;
|
||||
case K_OBJ_DRIVER_CHARGER: ret = "charger driver"; break;
|
||||
case K_OBJ_DRIVER_CLOCK_CONTROL: ret = "clock_control driver"; break;
|
||||
case K_OBJ_DRIVER_COMPARATOR: ret = "comparator driver"; break;
|
||||
case K_OBJ_DRIVER_COREDUMP: ret = "coredump driver"; break;
|
||||
case K_OBJ_DRIVER_COUNTER: ret = "counter driver"; break;
|
||||
case K_OBJ_DRIVER_CRC: ret = "crc driver"; break;
|
||||
case K_OBJ_DRIVER_DAC: ret = "dac driver"; break;
|
||||
case K_OBJ_DRIVER_DAI: ret = "dai driver"; break;
|
||||
case K_OBJ_DRIVER_DISPLAY: ret = "display driver"; break;
|
||||
case K_OBJ_DRIVER_DMA: ret = "dma driver"; break;
|
||||
case K_OBJ_DRIVER_EDAC: ret = "edac driver"; break;
|
||||
case K_OBJ_DRIVER_EEPROM: ret = "eeprom driver"; break;
|
||||
case K_OBJ_DRIVER_EMUL_BBRAM: ret = "emul_bbram driver"; break;
|
||||
case K_OBJ_DRIVER_FUEL_GAUGE_EMUL: ret = "fuel_gauge_emul driver"; break;
|
||||
case K_OBJ_DRIVER_EMUL_SENSOR: ret = "emul_sensor driver"; break;
|
||||
case K_OBJ_DRIVER_ENTROPY: ret = "entropy driver"; break;
|
||||
case K_OBJ_DRIVER_ESPI: ret = "espi driver"; break;
|
||||
case K_OBJ_DRIVER_ESPI_SAF: ret = "espi_saf driver"; break;
|
||||
case K_OBJ_DRIVER_FLASH: ret = "flash driver"; break;
|
||||
case K_OBJ_DRIVER_FPGA: ret = "fpga driver"; break;
|
||||
case K_OBJ_DRIVER_FUEL_GAUGE: ret = "fuel_gauge driver"; break;
|
||||
case K_OBJ_DRIVER_GNSS: ret = "gnss driver"; break;
|
||||
case K_OBJ_DRIVER_HAPTICS: ret = "haptics driver"; break;
|
||||
case K_OBJ_DRIVER_HWSPINLOCK: ret = "hwspinlock driver"; break;
|
||||
case K_OBJ_DRIVER_I2C: ret = "i2c driver"; break;
|
||||
case K_OBJ_DRIVER_I2C_TARGET: ret = "i2c_target driver"; break;
|
||||
case K_OBJ_DRIVER_I2S: ret = "i2s driver"; break;
|
||||
case K_OBJ_DRIVER_I3C: ret = "i3c driver"; break;
|
||||
case K_OBJ_DRIVER_IPM: ret = "ipm driver"; break;
|
||||
case K_OBJ_DRIVER_LED: ret = "led driver"; break;
|
||||
case K_OBJ_DRIVER_LED_STRIP: ret = "led_strip driver"; break;
|
||||
case K_OBJ_DRIVER_LORA: ret = "lora driver"; break;
|
||||
case K_OBJ_DRIVER_MBOX: ret = "mbox driver"; break;
|
||||
case K_OBJ_DRIVER_MDIO: ret = "mdio driver"; break;
|
||||
case K_OBJ_DRIVER_MIPI_DBI: ret = "mipi_dbi driver"; break;
|
||||
case K_OBJ_DRIVER_MIPI_DSI: ret = "mipi_dsi driver"; break;
|
||||
case K_OBJ_DRIVER_MSPI: ret = "mspi driver"; break;
|
||||
case K_OBJ_DRIVER_OPAMP: ret = "opamp driver"; break;
|
||||
case K_OBJ_DRIVER_OTP: ret = "otp driver"; break;
|
||||
case K_OBJ_DRIVER_PECI: ret = "peci driver"; break;
|
||||
case K_OBJ_DRIVER_PS2: ret = "ps2 driver"; break;
|
||||
case K_OBJ_DRIVER_PTP_CLOCK: ret = "ptp_clock driver"; break;
|
||||
case K_OBJ_DRIVER_PWM: ret = "pwm driver"; break;
|
||||
case K_OBJ_DRIVER_REGULATOR_PARENT: ret = "regulator_parent driver"; break;
|
||||
case K_OBJ_DRIVER_REGULATOR: ret = "regulator driver"; break;
|
||||
case K_OBJ_DRIVER_RESET: ret = "reset driver"; break;
|
||||
case K_OBJ_DRIVER_RETAINED_MEM: ret = "retained_mem driver"; break;
|
||||
case K_OBJ_DRIVER_RTC: ret = "rtc driver"; break;
|
||||
case K_OBJ_DRIVER_SDHC: ret = "sdhc driver"; break;
|
||||
case K_OBJ_DRIVER_SENSOR: ret = "sensor driver"; break;
|
||||
case K_OBJ_DRIVER_SMBUS: ret = "smbus driver"; break;
|
||||
case K_OBJ_DRIVER_SYSCON: ret = "syscon driver"; break;
|
||||
case K_OBJ_DRIVER_TEE: ret = "tee driver"; break;
|
||||
case K_OBJ_DRIVER_UAOL: ret = "uaol driver"; break;
|
||||
case K_OBJ_DRIVER_VIDEO: ret = "video driver"; break;
|
||||
case K_OBJ_DRIVER_VIRTIO: ret = "virtio driver"; break;
|
||||
case K_OBJ_DRIVER_W1: ret = "w1 driver"; break;
|
||||
case K_OBJ_DRIVER_WDT: ret = "wdt driver"; break;
|
||||
case K_OBJ_DRIVER_WUC: ret = "wuc driver"; break;
|
||||
case K_OBJ_DRIVER_CAN_TRANSCEIVER: ret = "can_transceiver driver"; break;
|
||||
case K_OBJ_DRIVER_NRF_CLOCK_CONTROL: ret = "nrf_clock_control driver"; break;
|
||||
case K_OBJ_DRIVER_I3C_TARGET: ret = "i3c_target driver"; break;
|
||||
case K_OBJ_DRIVER_ITS: ret = "its driver"; break;
|
||||
case K_OBJ_DRIVER_VTD: ret = "vtd driver"; break;
|
||||
case K_OBJ_DRIVER_RENESAS_ELC: ret = "renesas_elc driver"; break;
|
||||
case K_OBJ_DRIVER_TGPIO: ret = "tgpio driver"; break;
|
||||
case K_OBJ_DRIVER_PCIE_CTRL: ret = "pcie_ctrl driver"; break;
|
||||
case K_OBJ_DRIVER_PCIE_EP: ret = "pcie_ep driver"; break;
|
||||
case K_OBJ_DRIVER_PSI5: ret = "psi5 driver"; break;
|
||||
case K_OBJ_DRIVER_SENT: ret = "sent driver"; break;
|
||||
case K_OBJ_DRIVER_SVC: ret = "svc driver"; break;
|
||||
case K_OBJ_DRIVER_STEPPER: ret = "stepper driver"; break;
|
||||
case K_OBJ_DRIVER_STEPPER_CTRL: ret = "stepper_ctrl driver"; break;
|
||||
case K_OBJ_DRIVER_UART: ret = "uart driver"; break;
|
||||
case K_OBJ_DRIVER_BC12_EMUL: ret = "bc12_emul driver"; break;
|
||||
case K_OBJ_DRIVER_BC12: ret = "bc12 driver"; break;
|
||||
case K_OBJ_DRIVER_USBC_PPC: ret = "usbc_ppc driver"; break;
|
||||
case K_OBJ_DRIVER_TCPC: ret = "tcpc driver"; break;
|
||||
case K_OBJ_DRIVER_USBC_VBUS: ret = "usbc_vbus driver"; break;
|
||||
case K_OBJ_DRIVER_IVSHMEM: ret = "ivshmem driver"; break;
|
||||
case K_OBJ_DRIVER_ETHPHY: ret = "ethphy driver"; break;
|
||||
812
build/zephyr/include/generated/zephyr/syscall_dispatch.c
Normal file
812
build/zephyr/include/generated/zephyr/syscall_dispatch.c
Normal file
@@ -0,0 +1,812 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#include <zephyr/llext/symbol.h>
|
||||
|
||||
/* Weak handler functions that get replaced by the real ones unless a system
|
||||
* call is not implemented due to kernel configuration.
|
||||
*/
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_xtensa_user_fault(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_zephyr_read_stdin(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_zephyr_write_stdout(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_zephyr_fputc(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_zephyr_fwrite(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_sys_clock_getrtoffset(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_sys_clock_settime(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_sys_clock_nanosleep(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_z_sys_mutex_kernel_lock(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_z_sys_mutex_kernel_unlock(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_z_log_msg_simple_create_0(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_z_log_msg_simple_create_1(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_z_log_msg_simple_create_2(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_z_log_msg_static_create(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_log_panic(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_log_process(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_log_buffered_cnt(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_log_filter_set(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_log_frontend_filter_set(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_gpio_pin_interrupt_configure(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_gpio_pin_configure(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_gpio_port_get_direction(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_gpio_pin_get_config(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_gpio_port_get_raw(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_gpio_port_set_masked_raw(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_gpio_port_set_bits_raw(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_gpio_port_clear_bits_raw(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_gpio_port_toggle_bits(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_gpio_get_pending_int(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_err_check(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_poll_in(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_poll_in_u16(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_poll_out(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_poll_out_u16(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_configure(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_config_get(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_irq_tx_enable(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_irq_tx_disable(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_irq_rx_enable(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_irq_rx_disable(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_irq_err_enable(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_irq_err_disable(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_irq_is_pending(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_irq_update(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_tx(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_tx_u16(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_tx_abort(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_rx_enable(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_rx_enable_u16(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_rx_disable(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_line_ctrl_set(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_line_ctrl_get(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_uart_drv_cmd(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_spi_transceive(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_spi_release(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_device_get_binding(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_device_is_ready(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_device_init(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_device_deinit(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_device_get_by_dt_nodelabel(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_stack_alloc(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_stack_free(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_create(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_stack_space_get(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_runtime_stack_unused_threshold_pct_set(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_runtime_stack_unused_threshold_set(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_runtime_stack_unused_threshold_get(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_join(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_sleep(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_usleep(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_busy_wait(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_yield(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_wakeup(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_sched_current_thread_query(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_abort(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_timeout_expires_ticks(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_timeout_remaining_ticks(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_priority_get(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_priority_set(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_deadline_set(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_absolute_deadline_set(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_reschedule(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_suspend(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_resume(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_is_preempt_thread(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_custom_data_set(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_custom_data_get(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_name_set(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_thread_name_copy(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_timer_start(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_timer_stop(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_timer_status_get(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_timer_status_sync(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_timer_expires_ticks(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_timer_remaining_ticks(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_timer_user_data_set(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_timer_user_data_get(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_uptime_ticks(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_queue_init(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_queue_cancel_wait(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_queue_alloc_append(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_queue_alloc_prepend(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_queue_get(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_queue_is_empty(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_queue_peek_head(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_queue_peek_tail(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_futex_wait(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_futex_wake(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_event_init(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_event_post(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_event_set(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_event_set_masked(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_event_clear(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_event_wait(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_event_wait_all(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_event_wait_safe(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_event_wait_all_safe(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_stack_alloc_init(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_stack_push(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_stack_pop(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_mutex_init(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_mutex_lock(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_mutex_unlock(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_condvar_init(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_condvar_signal(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_condvar_broadcast(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_condvar_wait(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_sem_init(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_sem_take(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_sem_give(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_sem_reset(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_sem_count_get(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_msgq_alloc_init(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_msgq_put(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_msgq_put_front(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_msgq_get(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_msgq_peek(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_msgq_peek_at(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_msgq_purge(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_msgq_num_free_get(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_msgq_get_attrs(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_msgq_num_used_get(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_pipe_init(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_pipe_write(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_pipe_read(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_pipe_reset(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_pipe_close(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_poll(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_poll_signal_init(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_poll_signal_reset(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_poll_signal_check(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_poll_signal_raise(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_str_out(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_float_disable(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_float_enable(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_object_access_check(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_k_object_alloc_size(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_sys_clock_hw_cycles_per_sec_runtime_get(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
__weak ALIAS_OF(handler_no_syscall)
|
||||
uintptr_t z_mrsh_z_errno(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
|
||||
uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
extern uintptr_t z_mrsh_k_object_release(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
extern uintptr_t z_mrsh_k_object_access_grant(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
extern uintptr_t z_mrsh_k_object_alloc(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf);
|
||||
|
||||
const _k_syscall_handler_t _k_syscall_table[K_SYSCALL_LIMIT] = {
|
||||
[K_SYSCALL_XTENSA_USER_FAULT] = z_mrsh_xtensa_user_fault,
|
||||
[K_SYSCALL_ZEPHYR_READ_STDIN] = z_mrsh_zephyr_read_stdin,
|
||||
[K_SYSCALL_ZEPHYR_WRITE_STDOUT] = z_mrsh_zephyr_write_stdout,
|
||||
[K_SYSCALL_ZEPHYR_FPUTC] = z_mrsh_zephyr_fputc,
|
||||
[K_SYSCALL_ZEPHYR_FWRITE] = z_mrsh_zephyr_fwrite,
|
||||
[K_SYSCALL_SYS_CLOCK_GETRTOFFSET] = z_mrsh_sys_clock_getrtoffset,
|
||||
[K_SYSCALL_SYS_CLOCK_SETTIME] = z_mrsh_sys_clock_settime,
|
||||
[K_SYSCALL_SYS_CLOCK_NANOSLEEP] = z_mrsh_sys_clock_nanosleep,
|
||||
[K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK] = z_mrsh_z_sys_mutex_kernel_lock,
|
||||
[K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK] = z_mrsh_z_sys_mutex_kernel_unlock,
|
||||
[K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0] = z_mrsh_z_log_msg_simple_create_0,
|
||||
[K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1] = z_mrsh_z_log_msg_simple_create_1,
|
||||
[K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2] = z_mrsh_z_log_msg_simple_create_2,
|
||||
[K_SYSCALL_Z_LOG_MSG_STATIC_CREATE] = z_mrsh_z_log_msg_static_create,
|
||||
[K_SYSCALL_LOG_PANIC] = z_mrsh_log_panic,
|
||||
[K_SYSCALL_LOG_PROCESS] = z_mrsh_log_process,
|
||||
[K_SYSCALL_LOG_BUFFERED_CNT] = z_mrsh_log_buffered_cnt,
|
||||
[K_SYSCALL_LOG_FILTER_SET] = z_mrsh_log_filter_set,
|
||||
[K_SYSCALL_LOG_FRONTEND_FILTER_SET] = z_mrsh_log_frontend_filter_set,
|
||||
[K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE] = z_mrsh_gpio_pin_interrupt_configure,
|
||||
[K_SYSCALL_GPIO_PIN_CONFIGURE] = z_mrsh_gpio_pin_configure,
|
||||
[K_SYSCALL_GPIO_PORT_GET_DIRECTION] = z_mrsh_gpio_port_get_direction,
|
||||
[K_SYSCALL_GPIO_PIN_GET_CONFIG] = z_mrsh_gpio_pin_get_config,
|
||||
[K_SYSCALL_GPIO_PORT_GET_RAW] = z_mrsh_gpio_port_get_raw,
|
||||
[K_SYSCALL_GPIO_PORT_SET_MASKED_RAW] = z_mrsh_gpio_port_set_masked_raw,
|
||||
[K_SYSCALL_GPIO_PORT_SET_BITS_RAW] = z_mrsh_gpio_port_set_bits_raw,
|
||||
[K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW] = z_mrsh_gpio_port_clear_bits_raw,
|
||||
[K_SYSCALL_GPIO_PORT_TOGGLE_BITS] = z_mrsh_gpio_port_toggle_bits,
|
||||
[K_SYSCALL_GPIO_GET_PENDING_INT] = z_mrsh_gpio_get_pending_int,
|
||||
[K_SYSCALL_UART_ERR_CHECK] = z_mrsh_uart_err_check,
|
||||
[K_SYSCALL_UART_POLL_IN] = z_mrsh_uart_poll_in,
|
||||
[K_SYSCALL_UART_POLL_IN_U16] = z_mrsh_uart_poll_in_u16,
|
||||
[K_SYSCALL_UART_POLL_OUT] = z_mrsh_uart_poll_out,
|
||||
[K_SYSCALL_UART_POLL_OUT_U16] = z_mrsh_uart_poll_out_u16,
|
||||
[K_SYSCALL_UART_CONFIGURE] = z_mrsh_uart_configure,
|
||||
[K_SYSCALL_UART_CONFIG_GET] = z_mrsh_uart_config_get,
|
||||
[K_SYSCALL_UART_IRQ_TX_ENABLE] = z_mrsh_uart_irq_tx_enable,
|
||||
[K_SYSCALL_UART_IRQ_TX_DISABLE] = z_mrsh_uart_irq_tx_disable,
|
||||
[K_SYSCALL_UART_IRQ_RX_ENABLE] = z_mrsh_uart_irq_rx_enable,
|
||||
[K_SYSCALL_UART_IRQ_RX_DISABLE] = z_mrsh_uart_irq_rx_disable,
|
||||
[K_SYSCALL_UART_IRQ_ERR_ENABLE] = z_mrsh_uart_irq_err_enable,
|
||||
[K_SYSCALL_UART_IRQ_ERR_DISABLE] = z_mrsh_uart_irq_err_disable,
|
||||
[K_SYSCALL_UART_IRQ_IS_PENDING] = z_mrsh_uart_irq_is_pending,
|
||||
[K_SYSCALL_UART_IRQ_UPDATE] = z_mrsh_uart_irq_update,
|
||||
[K_SYSCALL_UART_TX] = z_mrsh_uart_tx,
|
||||
[K_SYSCALL_UART_TX_U16] = z_mrsh_uart_tx_u16,
|
||||
[K_SYSCALL_UART_TX_ABORT] = z_mrsh_uart_tx_abort,
|
||||
[K_SYSCALL_UART_RX_ENABLE] = z_mrsh_uart_rx_enable,
|
||||
[K_SYSCALL_UART_RX_ENABLE_U16] = z_mrsh_uart_rx_enable_u16,
|
||||
[K_SYSCALL_UART_RX_DISABLE] = z_mrsh_uart_rx_disable,
|
||||
[K_SYSCALL_UART_LINE_CTRL_SET] = z_mrsh_uart_line_ctrl_set,
|
||||
[K_SYSCALL_UART_LINE_CTRL_GET] = z_mrsh_uart_line_ctrl_get,
|
||||
[K_SYSCALL_UART_DRV_CMD] = z_mrsh_uart_drv_cmd,
|
||||
[K_SYSCALL_SPI_TRANSCEIVE] = z_mrsh_spi_transceive,
|
||||
[K_SYSCALL_SPI_RELEASE] = z_mrsh_spi_release,
|
||||
[K_SYSCALL_DEVICE_GET_BINDING] = z_mrsh_device_get_binding,
|
||||
[K_SYSCALL_DEVICE_IS_READY] = z_mrsh_device_is_ready,
|
||||
[K_SYSCALL_DEVICE_INIT] = z_mrsh_device_init,
|
||||
[K_SYSCALL_DEVICE_DEINIT] = z_mrsh_device_deinit,
|
||||
[K_SYSCALL_DEVICE_GET_BY_DT_NODELABEL] = z_mrsh_device_get_by_dt_nodelabel,
|
||||
[K_SYSCALL_K_THREAD_STACK_ALLOC] = z_mrsh_k_thread_stack_alloc,
|
||||
[K_SYSCALL_K_THREAD_STACK_FREE] = z_mrsh_k_thread_stack_free,
|
||||
[K_SYSCALL_K_THREAD_CREATE] = z_mrsh_k_thread_create,
|
||||
[K_SYSCALL_K_THREAD_STACK_SPACE_GET] = z_mrsh_k_thread_stack_space_get,
|
||||
[K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_PCT_SET] = z_mrsh_k_thread_runtime_stack_unused_threshold_pct_set,
|
||||
[K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_SET] = z_mrsh_k_thread_runtime_stack_unused_threshold_set,
|
||||
[K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_GET] = z_mrsh_k_thread_runtime_stack_unused_threshold_get,
|
||||
[K_SYSCALL_K_THREAD_JOIN] = z_mrsh_k_thread_join,
|
||||
[K_SYSCALL_K_SLEEP] = z_mrsh_k_sleep,
|
||||
[K_SYSCALL_K_USLEEP] = z_mrsh_k_usleep,
|
||||
[K_SYSCALL_K_BUSY_WAIT] = z_mrsh_k_busy_wait,
|
||||
[K_SYSCALL_K_YIELD] = z_mrsh_k_yield,
|
||||
[K_SYSCALL_K_WAKEUP] = z_mrsh_k_wakeup,
|
||||
[K_SYSCALL_K_SCHED_CURRENT_THREAD_QUERY] = z_mrsh_k_sched_current_thread_query,
|
||||
[K_SYSCALL_K_THREAD_ABORT] = z_mrsh_k_thread_abort,
|
||||
[K_SYSCALL_K_THREAD_TIMEOUT_EXPIRES_TICKS] = z_mrsh_k_thread_timeout_expires_ticks,
|
||||
[K_SYSCALL_K_THREAD_TIMEOUT_REMAINING_TICKS] = z_mrsh_k_thread_timeout_remaining_ticks,
|
||||
[K_SYSCALL_K_THREAD_PRIORITY_GET] = z_mrsh_k_thread_priority_get,
|
||||
[K_SYSCALL_K_THREAD_PRIORITY_SET] = z_mrsh_k_thread_priority_set,
|
||||
[K_SYSCALL_K_THREAD_DEADLINE_SET] = z_mrsh_k_thread_deadline_set,
|
||||
[K_SYSCALL_K_THREAD_ABSOLUTE_DEADLINE_SET] = z_mrsh_k_thread_absolute_deadline_set,
|
||||
[K_SYSCALL_K_RESCHEDULE] = z_mrsh_k_reschedule,
|
||||
[K_SYSCALL_K_THREAD_SUSPEND] = z_mrsh_k_thread_suspend,
|
||||
[K_SYSCALL_K_THREAD_RESUME] = z_mrsh_k_thread_resume,
|
||||
[K_SYSCALL_K_IS_PREEMPT_THREAD] = z_mrsh_k_is_preempt_thread,
|
||||
[K_SYSCALL_K_THREAD_CUSTOM_DATA_SET] = z_mrsh_k_thread_custom_data_set,
|
||||
[K_SYSCALL_K_THREAD_CUSTOM_DATA_GET] = z_mrsh_k_thread_custom_data_get,
|
||||
[K_SYSCALL_K_THREAD_NAME_SET] = z_mrsh_k_thread_name_set,
|
||||
[K_SYSCALL_K_THREAD_NAME_COPY] = z_mrsh_k_thread_name_copy,
|
||||
[K_SYSCALL_K_TIMER_START] = z_mrsh_k_timer_start,
|
||||
[K_SYSCALL_K_TIMER_STOP] = z_mrsh_k_timer_stop,
|
||||
[K_SYSCALL_K_TIMER_STATUS_GET] = z_mrsh_k_timer_status_get,
|
||||
[K_SYSCALL_K_TIMER_STATUS_SYNC] = z_mrsh_k_timer_status_sync,
|
||||
[K_SYSCALL_K_TIMER_EXPIRES_TICKS] = z_mrsh_k_timer_expires_ticks,
|
||||
[K_SYSCALL_K_TIMER_REMAINING_TICKS] = z_mrsh_k_timer_remaining_ticks,
|
||||
[K_SYSCALL_K_TIMER_USER_DATA_SET] = z_mrsh_k_timer_user_data_set,
|
||||
[K_SYSCALL_K_TIMER_USER_DATA_GET] = z_mrsh_k_timer_user_data_get,
|
||||
[K_SYSCALL_K_UPTIME_TICKS] = z_mrsh_k_uptime_ticks,
|
||||
[K_SYSCALL_K_QUEUE_INIT] = z_mrsh_k_queue_init,
|
||||
[K_SYSCALL_K_QUEUE_CANCEL_WAIT] = z_mrsh_k_queue_cancel_wait,
|
||||
[K_SYSCALL_K_QUEUE_ALLOC_APPEND] = z_mrsh_k_queue_alloc_append,
|
||||
[K_SYSCALL_K_QUEUE_ALLOC_PREPEND] = z_mrsh_k_queue_alloc_prepend,
|
||||
[K_SYSCALL_K_QUEUE_GET] = z_mrsh_k_queue_get,
|
||||
[K_SYSCALL_K_QUEUE_IS_EMPTY] = z_mrsh_k_queue_is_empty,
|
||||
[K_SYSCALL_K_QUEUE_PEEK_HEAD] = z_mrsh_k_queue_peek_head,
|
||||
[K_SYSCALL_K_QUEUE_PEEK_TAIL] = z_mrsh_k_queue_peek_tail,
|
||||
[K_SYSCALL_K_FUTEX_WAIT] = z_mrsh_k_futex_wait,
|
||||
[K_SYSCALL_K_FUTEX_WAKE] = z_mrsh_k_futex_wake,
|
||||
[K_SYSCALL_K_EVENT_INIT] = z_mrsh_k_event_init,
|
||||
[K_SYSCALL_K_EVENT_POST] = z_mrsh_k_event_post,
|
||||
[K_SYSCALL_K_EVENT_SET] = z_mrsh_k_event_set,
|
||||
[K_SYSCALL_K_EVENT_SET_MASKED] = z_mrsh_k_event_set_masked,
|
||||
[K_SYSCALL_K_EVENT_CLEAR] = z_mrsh_k_event_clear,
|
||||
[K_SYSCALL_K_EVENT_WAIT] = z_mrsh_k_event_wait,
|
||||
[K_SYSCALL_K_EVENT_WAIT_ALL] = z_mrsh_k_event_wait_all,
|
||||
[K_SYSCALL_K_EVENT_WAIT_SAFE] = z_mrsh_k_event_wait_safe,
|
||||
[K_SYSCALL_K_EVENT_WAIT_ALL_SAFE] = z_mrsh_k_event_wait_all_safe,
|
||||
[K_SYSCALL_K_STACK_ALLOC_INIT] = z_mrsh_k_stack_alloc_init,
|
||||
[K_SYSCALL_K_STACK_PUSH] = z_mrsh_k_stack_push,
|
||||
[K_SYSCALL_K_STACK_POP] = z_mrsh_k_stack_pop,
|
||||
[K_SYSCALL_K_MUTEX_INIT] = z_mrsh_k_mutex_init,
|
||||
[K_SYSCALL_K_MUTEX_LOCK] = z_mrsh_k_mutex_lock,
|
||||
[K_SYSCALL_K_MUTEX_UNLOCK] = z_mrsh_k_mutex_unlock,
|
||||
[K_SYSCALL_K_CONDVAR_INIT] = z_mrsh_k_condvar_init,
|
||||
[K_SYSCALL_K_CONDVAR_SIGNAL] = z_mrsh_k_condvar_signal,
|
||||
[K_SYSCALL_K_CONDVAR_BROADCAST] = z_mrsh_k_condvar_broadcast,
|
||||
[K_SYSCALL_K_CONDVAR_WAIT] = z_mrsh_k_condvar_wait,
|
||||
[K_SYSCALL_K_SEM_INIT] = z_mrsh_k_sem_init,
|
||||
[K_SYSCALL_K_SEM_TAKE] = z_mrsh_k_sem_take,
|
||||
[K_SYSCALL_K_SEM_GIVE] = z_mrsh_k_sem_give,
|
||||
[K_SYSCALL_K_SEM_RESET] = z_mrsh_k_sem_reset,
|
||||
[K_SYSCALL_K_SEM_COUNT_GET] = z_mrsh_k_sem_count_get,
|
||||
[K_SYSCALL_K_MSGQ_ALLOC_INIT] = z_mrsh_k_msgq_alloc_init,
|
||||
[K_SYSCALL_K_MSGQ_PUT] = z_mrsh_k_msgq_put,
|
||||
[K_SYSCALL_K_MSGQ_PUT_FRONT] = z_mrsh_k_msgq_put_front,
|
||||
[K_SYSCALL_K_MSGQ_GET] = z_mrsh_k_msgq_get,
|
||||
[K_SYSCALL_K_MSGQ_PEEK] = z_mrsh_k_msgq_peek,
|
||||
[K_SYSCALL_K_MSGQ_PEEK_AT] = z_mrsh_k_msgq_peek_at,
|
||||
[K_SYSCALL_K_MSGQ_PURGE] = z_mrsh_k_msgq_purge,
|
||||
[K_SYSCALL_K_MSGQ_NUM_FREE_GET] = z_mrsh_k_msgq_num_free_get,
|
||||
[K_SYSCALL_K_MSGQ_GET_ATTRS] = z_mrsh_k_msgq_get_attrs,
|
||||
[K_SYSCALL_K_MSGQ_NUM_USED_GET] = z_mrsh_k_msgq_num_used_get,
|
||||
[K_SYSCALL_K_PIPE_INIT] = z_mrsh_k_pipe_init,
|
||||
[K_SYSCALL_K_PIPE_WRITE] = z_mrsh_k_pipe_write,
|
||||
[K_SYSCALL_K_PIPE_READ] = z_mrsh_k_pipe_read,
|
||||
[K_SYSCALL_K_PIPE_RESET] = z_mrsh_k_pipe_reset,
|
||||
[K_SYSCALL_K_PIPE_CLOSE] = z_mrsh_k_pipe_close,
|
||||
[K_SYSCALL_K_POLL] = z_mrsh_k_poll,
|
||||
[K_SYSCALL_K_POLL_SIGNAL_INIT] = z_mrsh_k_poll_signal_init,
|
||||
[K_SYSCALL_K_POLL_SIGNAL_RESET] = z_mrsh_k_poll_signal_reset,
|
||||
[K_SYSCALL_K_POLL_SIGNAL_CHECK] = z_mrsh_k_poll_signal_check,
|
||||
[K_SYSCALL_K_POLL_SIGNAL_RAISE] = z_mrsh_k_poll_signal_raise,
|
||||
[K_SYSCALL_K_STR_OUT] = z_mrsh_k_str_out,
|
||||
[K_SYSCALL_K_FLOAT_DISABLE] = z_mrsh_k_float_disable,
|
||||
[K_SYSCALL_K_FLOAT_ENABLE] = z_mrsh_k_float_enable,
|
||||
[K_SYSCALL_K_OBJECT_ACCESS_GRANT] = z_mrsh_k_object_access_grant,
|
||||
[K_SYSCALL_K_OBJECT_RELEASE] = z_mrsh_k_object_release,
|
||||
[K_SYSCALL_K_OBJECT_ACCESS_CHECK] = z_mrsh_k_object_access_check,
|
||||
[K_SYSCALL_K_OBJECT_ALLOC] = z_mrsh_k_object_alloc,
|
||||
[K_SYSCALL_K_OBJECT_ALLOC_SIZE] = z_mrsh_k_object_alloc_size,
|
||||
[K_SYSCALL_SYS_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_GET] = z_mrsh_sys_clock_hw_cycles_per_sec_runtime_get,
|
||||
[K_SYSCALL_Z_ERRNO] = z_mrsh_z_errno,
|
||||
[K_SYSCALL_BAD] = handler_bad_syscall
|
||||
};
|
||||
335
build/zephyr/include/generated/zephyr/syscall_exports_llext.c
Normal file
335
build/zephyr/include/generated/zephyr/syscall_exports_llext.c
Normal file
@@ -0,0 +1,335 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
/*
|
||||
* Export the implementation functions of all emitted syscalls.
|
||||
* Only the symbol names are relevant in this file, they will be
|
||||
* resolved to the actual implementation functions by the linker.
|
||||
*/
|
||||
|
||||
/* Symbol declarations */
|
||||
extern void * const z_impl_device_deinit;
|
||||
extern void * const z_impl_device_get_binding;
|
||||
extern void * const z_impl_device_get_by_dt_nodelabel;
|
||||
extern void * const z_impl_device_init;
|
||||
extern void * const z_impl_device_is_ready;
|
||||
extern void * const z_impl_gpio_get_pending_int;
|
||||
extern void * const z_impl_gpio_pin_configure;
|
||||
extern void * const z_impl_gpio_pin_get_config;
|
||||
extern void * const z_impl_gpio_pin_interrupt_configure;
|
||||
extern void * const z_impl_gpio_port_clear_bits_raw;
|
||||
extern void * const z_impl_gpio_port_get_direction;
|
||||
extern void * const z_impl_gpio_port_get_raw;
|
||||
extern void * const z_impl_gpio_port_set_bits_raw;
|
||||
extern void * const z_impl_gpio_port_set_masked_raw;
|
||||
extern void * const z_impl_gpio_port_toggle_bits;
|
||||
extern void * const z_impl_k_busy_wait;
|
||||
extern void * const z_impl_k_condvar_broadcast;
|
||||
extern void * const z_impl_k_condvar_init;
|
||||
extern void * const z_impl_k_condvar_signal;
|
||||
extern void * const z_impl_k_condvar_wait;
|
||||
extern void * const z_impl_k_event_clear;
|
||||
extern void * const z_impl_k_event_init;
|
||||
extern void * const z_impl_k_event_post;
|
||||
extern void * const z_impl_k_event_set;
|
||||
extern void * const z_impl_k_event_set_masked;
|
||||
extern void * const z_impl_k_event_wait;
|
||||
extern void * const z_impl_k_event_wait_all;
|
||||
extern void * const z_impl_k_event_wait_all_safe;
|
||||
extern void * const z_impl_k_event_wait_safe;
|
||||
extern void * const z_impl_k_float_disable;
|
||||
extern void * const z_impl_k_float_enable;
|
||||
extern void * const z_impl_k_futex_wait;
|
||||
extern void * const z_impl_k_futex_wake;
|
||||
extern void * const z_impl_k_is_preempt_thread;
|
||||
extern void * const z_impl_k_msgq_alloc_init;
|
||||
extern void * const z_impl_k_msgq_get;
|
||||
extern void * const z_impl_k_msgq_get_attrs;
|
||||
extern void * const z_impl_k_msgq_num_free_get;
|
||||
extern void * const z_impl_k_msgq_num_used_get;
|
||||
extern void * const z_impl_k_msgq_peek;
|
||||
extern void * const z_impl_k_msgq_peek_at;
|
||||
extern void * const z_impl_k_msgq_purge;
|
||||
extern void * const z_impl_k_msgq_put;
|
||||
extern void * const z_impl_k_msgq_put_front;
|
||||
extern void * const z_impl_k_mutex_init;
|
||||
extern void * const z_impl_k_mutex_lock;
|
||||
extern void * const z_impl_k_mutex_unlock;
|
||||
extern void * const z_impl_k_object_access_check;
|
||||
extern void * const z_impl_k_object_access_grant;
|
||||
extern void * const z_impl_k_object_alloc;
|
||||
extern void * const z_impl_k_object_alloc_size;
|
||||
extern void * const z_impl_k_object_release;
|
||||
extern void * const z_impl_k_pipe_close;
|
||||
extern void * const z_impl_k_pipe_init;
|
||||
extern void * const z_impl_k_pipe_read;
|
||||
extern void * const z_impl_k_pipe_reset;
|
||||
extern void * const z_impl_k_pipe_write;
|
||||
extern void * const z_impl_k_poll;
|
||||
extern void * const z_impl_k_poll_signal_check;
|
||||
extern void * const z_impl_k_poll_signal_init;
|
||||
extern void * const z_impl_k_poll_signal_raise;
|
||||
extern void * const z_impl_k_poll_signal_reset;
|
||||
extern void * const z_impl_k_queue_alloc_append;
|
||||
extern void * const z_impl_k_queue_alloc_prepend;
|
||||
extern void * const z_impl_k_queue_cancel_wait;
|
||||
extern void * const z_impl_k_queue_get;
|
||||
extern void * const z_impl_k_queue_init;
|
||||
extern void * const z_impl_k_queue_is_empty;
|
||||
extern void * const z_impl_k_queue_peek_head;
|
||||
extern void * const z_impl_k_queue_peek_tail;
|
||||
extern void * const z_impl_k_reschedule;
|
||||
extern void * const z_impl_k_sched_current_thread_query;
|
||||
extern void * const z_impl_k_sem_count_get;
|
||||
extern void * const z_impl_k_sem_give;
|
||||
extern void * const z_impl_k_sem_init;
|
||||
extern void * const z_impl_k_sem_reset;
|
||||
extern void * const z_impl_k_sem_take;
|
||||
extern void * const z_impl_k_sleep;
|
||||
extern void * const z_impl_k_stack_alloc_init;
|
||||
extern void * const z_impl_k_stack_pop;
|
||||
extern void * const z_impl_k_stack_push;
|
||||
extern void * const z_impl_k_str_out;
|
||||
extern void * const z_impl_k_thread_abort;
|
||||
extern void * const z_impl_k_thread_absolute_deadline_set;
|
||||
extern void * const z_impl_k_thread_create;
|
||||
extern void * const z_impl_k_thread_custom_data_get;
|
||||
extern void * const z_impl_k_thread_custom_data_set;
|
||||
extern void * const z_impl_k_thread_deadline_set;
|
||||
extern void * const z_impl_k_thread_join;
|
||||
extern void * const z_impl_k_thread_name_copy;
|
||||
extern void * const z_impl_k_thread_name_set;
|
||||
extern void * const z_impl_k_thread_priority_get;
|
||||
extern void * const z_impl_k_thread_priority_set;
|
||||
extern void * const z_impl_k_thread_resume;
|
||||
extern void * const z_impl_k_thread_runtime_stack_unused_threshold_get;
|
||||
extern void * const z_impl_k_thread_runtime_stack_unused_threshold_pct_set;
|
||||
extern void * const z_impl_k_thread_runtime_stack_unused_threshold_set;
|
||||
extern void * const z_impl_k_thread_stack_alloc;
|
||||
extern void * const z_impl_k_thread_stack_free;
|
||||
extern void * const z_impl_k_thread_stack_space_get;
|
||||
extern void * const z_impl_k_thread_suspend;
|
||||
extern void * const z_impl_k_thread_timeout_expires_ticks;
|
||||
extern void * const z_impl_k_thread_timeout_remaining_ticks;
|
||||
extern void * const z_impl_k_timer_expires_ticks;
|
||||
extern void * const z_impl_k_timer_remaining_ticks;
|
||||
extern void * const z_impl_k_timer_start;
|
||||
extern void * const z_impl_k_timer_status_get;
|
||||
extern void * const z_impl_k_timer_status_sync;
|
||||
extern void * const z_impl_k_timer_stop;
|
||||
extern void * const z_impl_k_timer_user_data_get;
|
||||
extern void * const z_impl_k_timer_user_data_set;
|
||||
extern void * const z_impl_k_uptime_ticks;
|
||||
extern void * const z_impl_k_usleep;
|
||||
extern void * const z_impl_k_wakeup;
|
||||
extern void * const z_impl_k_yield;
|
||||
extern void * const z_impl_log_buffered_cnt;
|
||||
extern void * const z_impl_log_filter_set;
|
||||
extern void * const z_impl_log_frontend_filter_set;
|
||||
extern void * const z_impl_log_panic;
|
||||
extern void * const z_impl_log_process;
|
||||
extern void * const z_impl_spi_release;
|
||||
extern void * const z_impl_spi_transceive;
|
||||
extern void * const z_impl_sys_clock_getrtoffset;
|
||||
extern void * const z_impl_sys_clock_hw_cycles_per_sec_runtime_get;
|
||||
extern void * const z_impl_sys_clock_nanosleep;
|
||||
extern void * const z_impl_sys_clock_settime;
|
||||
extern void * const z_impl_uart_config_get;
|
||||
extern void * const z_impl_uart_configure;
|
||||
extern void * const z_impl_uart_drv_cmd;
|
||||
extern void * const z_impl_uart_err_check;
|
||||
extern void * const z_impl_uart_irq_err_disable;
|
||||
extern void * const z_impl_uart_irq_err_enable;
|
||||
extern void * const z_impl_uart_irq_is_pending;
|
||||
extern void * const z_impl_uart_irq_rx_disable;
|
||||
extern void * const z_impl_uart_irq_rx_enable;
|
||||
extern void * const z_impl_uart_irq_tx_disable;
|
||||
extern void * const z_impl_uart_irq_tx_enable;
|
||||
extern void * const z_impl_uart_irq_update;
|
||||
extern void * const z_impl_uart_line_ctrl_get;
|
||||
extern void * const z_impl_uart_line_ctrl_set;
|
||||
extern void * const z_impl_uart_poll_in;
|
||||
extern void * const z_impl_uart_poll_in_u16;
|
||||
extern void * const z_impl_uart_poll_out;
|
||||
extern void * const z_impl_uart_poll_out_u16;
|
||||
extern void * const z_impl_uart_rx_disable;
|
||||
extern void * const z_impl_uart_rx_enable;
|
||||
extern void * const z_impl_uart_rx_enable_u16;
|
||||
extern void * const z_impl_uart_tx;
|
||||
extern void * const z_impl_uart_tx_abort;
|
||||
extern void * const z_impl_uart_tx_u16;
|
||||
extern void * const z_impl_xtensa_user_fault;
|
||||
extern void * const z_impl_z_errno;
|
||||
extern void * const z_impl_z_log_msg_simple_create_0;
|
||||
extern void * const z_impl_z_log_msg_simple_create_1;
|
||||
extern void * const z_impl_z_log_msg_simple_create_2;
|
||||
extern void * const z_impl_z_log_msg_static_create;
|
||||
extern void * const z_impl_z_sys_mutex_kernel_lock;
|
||||
extern void * const z_impl_z_sys_mutex_kernel_unlock;
|
||||
extern void * const z_impl_zephyr_fputc;
|
||||
extern void * const z_impl_zephyr_fwrite;
|
||||
extern void * const z_impl_zephyr_read_stdin;
|
||||
extern void * const z_impl_zephyr_write_stdout;
|
||||
|
||||
/* Exported symbols */
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_device_deinit);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_device_get_binding);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_device_get_by_dt_nodelabel);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_device_init);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_device_is_ready);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_gpio_get_pending_int);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_gpio_pin_configure);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_gpio_pin_get_config);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_gpio_pin_interrupt_configure);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_gpio_port_clear_bits_raw);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_gpio_port_get_direction);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_gpio_port_get_raw);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_gpio_port_set_bits_raw);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_gpio_port_set_masked_raw);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_gpio_port_toggle_bits);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_busy_wait);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_condvar_broadcast);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_condvar_init);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_condvar_signal);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_condvar_wait);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_event_clear);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_event_init);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_event_post);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_event_set);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_event_set_masked);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_event_wait);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_event_wait_all);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_event_wait_all_safe);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_event_wait_safe);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_float_disable);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_float_enable);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_futex_wait);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_futex_wake);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_is_preempt_thread);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_msgq_alloc_init);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_msgq_get);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_msgq_get_attrs);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_msgq_num_free_get);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_msgq_num_used_get);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_msgq_peek);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_msgq_peek_at);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_msgq_purge);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_msgq_put);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_msgq_put_front);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_mutex_init);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_mutex_lock);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_mutex_unlock);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_object_access_check);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_object_access_grant);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_object_alloc);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_object_alloc_size);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_object_release);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_pipe_close);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_pipe_init);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_pipe_read);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_pipe_reset);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_pipe_write);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_poll);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_poll_signal_check);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_poll_signal_init);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_poll_signal_raise);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_poll_signal_reset);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_queue_alloc_append);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_queue_alloc_prepend);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_queue_cancel_wait);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_queue_get);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_queue_init);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_queue_is_empty);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_queue_peek_head);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_queue_peek_tail);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_reschedule);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_sched_current_thread_query);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_sem_count_get);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_sem_give);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_sem_init);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_sem_reset);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_sem_take);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_sleep);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_stack_alloc_init);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_stack_pop);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_stack_push);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_str_out);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_abort);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_absolute_deadline_set);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_create);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_custom_data_get);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_custom_data_set);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_deadline_set);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_join);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_name_copy);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_name_set);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_priority_get);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_priority_set);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_resume);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_runtime_stack_unused_threshold_get);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_runtime_stack_unused_threshold_pct_set);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_runtime_stack_unused_threshold_set);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_stack_alloc);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_stack_free);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_stack_space_get);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_suspend);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_timeout_expires_ticks);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_thread_timeout_remaining_ticks);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_timer_expires_ticks);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_timer_remaining_ticks);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_timer_start);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_timer_status_get);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_timer_status_sync);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_timer_stop);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_timer_user_data_get);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_timer_user_data_set);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_uptime_ticks);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_usleep);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_wakeup);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_k_yield);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_log_buffered_cnt);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_log_filter_set);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_log_frontend_filter_set);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_log_panic);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_log_process);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_spi_release);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_spi_transceive);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_sys_clock_getrtoffset);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_sys_clock_hw_cycles_per_sec_runtime_get);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_sys_clock_nanosleep);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_sys_clock_settime);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_config_get);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_configure);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_drv_cmd);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_err_check);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_irq_err_disable);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_irq_err_enable);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_irq_is_pending);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_irq_rx_disable);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_irq_rx_enable);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_irq_tx_disable);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_irq_tx_enable);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_irq_update);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_line_ctrl_get);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_line_ctrl_set);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_poll_in);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_poll_in_u16);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_poll_out);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_poll_out_u16);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_rx_disable);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_rx_enable);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_rx_enable_u16);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_tx);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_tx_abort);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_uart_tx_u16);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_xtensa_user_fault);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_z_errno);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_z_log_msg_simple_create_0);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_z_log_msg_simple_create_1);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_z_log_msg_simple_create_2);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_z_log_msg_static_create);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_z_sys_mutex_kernel_lock);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_z_sys_mutex_kernel_unlock);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_zephyr_fputc);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_zephyr_fwrite);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_zephyr_read_stdin);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_zephyr_write_stdout);
|
||||
662
build/zephyr/include/generated/zephyr/syscall_list.h
Normal file
662
build/zephyr/include/generated/zephyr/syscall_list.h
Normal file
@@ -0,0 +1,662 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef ZEPHYR_SYSCALL_LIST_H
|
||||
#define ZEPHYR_SYSCALL_LIST_H
|
||||
|
||||
#define K_SYSCALL_DEVICE_DEINIT 0
|
||||
#define K_SYSCALL_DEVICE_GET_BINDING 1
|
||||
#define K_SYSCALL_DEVICE_GET_BY_DT_NODELABEL 2
|
||||
#define K_SYSCALL_DEVICE_INIT 3
|
||||
#define K_SYSCALL_DEVICE_IS_READY 4
|
||||
#define K_SYSCALL_GPIO_GET_PENDING_INT 5
|
||||
#define K_SYSCALL_GPIO_PIN_CONFIGURE 6
|
||||
#define K_SYSCALL_GPIO_PIN_GET_CONFIG 7
|
||||
#define K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE 8
|
||||
#define K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW 9
|
||||
#define K_SYSCALL_GPIO_PORT_GET_DIRECTION 10
|
||||
#define K_SYSCALL_GPIO_PORT_GET_RAW 11
|
||||
#define K_SYSCALL_GPIO_PORT_SET_BITS_RAW 12
|
||||
#define K_SYSCALL_GPIO_PORT_SET_MASKED_RAW 13
|
||||
#define K_SYSCALL_GPIO_PORT_TOGGLE_BITS 14
|
||||
#define K_SYSCALL_K_BUSY_WAIT 15
|
||||
#define K_SYSCALL_K_CONDVAR_BROADCAST 16
|
||||
#define K_SYSCALL_K_CONDVAR_INIT 17
|
||||
#define K_SYSCALL_K_CONDVAR_SIGNAL 18
|
||||
#define K_SYSCALL_K_CONDVAR_WAIT 19
|
||||
#define K_SYSCALL_K_EVENT_CLEAR 20
|
||||
#define K_SYSCALL_K_EVENT_INIT 21
|
||||
#define K_SYSCALL_K_EVENT_POST 22
|
||||
#define K_SYSCALL_K_EVENT_SET 23
|
||||
#define K_SYSCALL_K_EVENT_SET_MASKED 24
|
||||
#define K_SYSCALL_K_EVENT_WAIT 25
|
||||
#define K_SYSCALL_K_EVENT_WAIT_ALL 26
|
||||
#define K_SYSCALL_K_EVENT_WAIT_ALL_SAFE 27
|
||||
#define K_SYSCALL_K_EVENT_WAIT_SAFE 28
|
||||
#define K_SYSCALL_K_FLOAT_DISABLE 29
|
||||
#define K_SYSCALL_K_FLOAT_ENABLE 30
|
||||
#define K_SYSCALL_K_FUTEX_WAIT 31
|
||||
#define K_SYSCALL_K_FUTEX_WAKE 32
|
||||
#define K_SYSCALL_K_IS_PREEMPT_THREAD 33
|
||||
#define K_SYSCALL_K_MSGQ_ALLOC_INIT 34
|
||||
#define K_SYSCALL_K_MSGQ_GET 35
|
||||
#define K_SYSCALL_K_MSGQ_GET_ATTRS 36
|
||||
#define K_SYSCALL_K_MSGQ_NUM_FREE_GET 37
|
||||
#define K_SYSCALL_K_MSGQ_NUM_USED_GET 38
|
||||
#define K_SYSCALL_K_MSGQ_PEEK 39
|
||||
#define K_SYSCALL_K_MSGQ_PEEK_AT 40
|
||||
#define K_SYSCALL_K_MSGQ_PURGE 41
|
||||
#define K_SYSCALL_K_MSGQ_PUT 42
|
||||
#define K_SYSCALL_K_MSGQ_PUT_FRONT 43
|
||||
#define K_SYSCALL_K_MUTEX_INIT 44
|
||||
#define K_SYSCALL_K_MUTEX_LOCK 45
|
||||
#define K_SYSCALL_K_MUTEX_UNLOCK 46
|
||||
#define K_SYSCALL_K_OBJECT_ACCESS_CHECK 47
|
||||
#define K_SYSCALL_K_OBJECT_ACCESS_GRANT 48
|
||||
#define K_SYSCALL_K_OBJECT_ALLOC 49
|
||||
#define K_SYSCALL_K_OBJECT_ALLOC_SIZE 50
|
||||
#define K_SYSCALL_K_OBJECT_RELEASE 51
|
||||
#define K_SYSCALL_K_PIPE_CLOSE 52
|
||||
#define K_SYSCALL_K_PIPE_INIT 53
|
||||
#define K_SYSCALL_K_PIPE_READ 54
|
||||
#define K_SYSCALL_K_PIPE_RESET 55
|
||||
#define K_SYSCALL_K_PIPE_WRITE 56
|
||||
#define K_SYSCALL_K_POLL 57
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_CHECK 58
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_INIT 59
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_RAISE 60
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_RESET 61
|
||||
#define K_SYSCALL_K_QUEUE_ALLOC_APPEND 62
|
||||
#define K_SYSCALL_K_QUEUE_ALLOC_PREPEND 63
|
||||
#define K_SYSCALL_K_QUEUE_CANCEL_WAIT 64
|
||||
#define K_SYSCALL_K_QUEUE_GET 65
|
||||
#define K_SYSCALL_K_QUEUE_INIT 66
|
||||
#define K_SYSCALL_K_QUEUE_IS_EMPTY 67
|
||||
#define K_SYSCALL_K_QUEUE_PEEK_HEAD 68
|
||||
#define K_SYSCALL_K_QUEUE_PEEK_TAIL 69
|
||||
#define K_SYSCALL_K_RESCHEDULE 70
|
||||
#define K_SYSCALL_K_SCHED_CURRENT_THREAD_QUERY 71
|
||||
#define K_SYSCALL_K_SEM_COUNT_GET 72
|
||||
#define K_SYSCALL_K_SEM_GIVE 73
|
||||
#define K_SYSCALL_K_SEM_INIT 74
|
||||
#define K_SYSCALL_K_SEM_RESET 75
|
||||
#define K_SYSCALL_K_SEM_TAKE 76
|
||||
#define K_SYSCALL_K_SLEEP 77
|
||||
#define K_SYSCALL_K_STACK_ALLOC_INIT 78
|
||||
#define K_SYSCALL_K_STACK_POP 79
|
||||
#define K_SYSCALL_K_STACK_PUSH 80
|
||||
#define K_SYSCALL_K_STR_OUT 81
|
||||
#define K_SYSCALL_K_THREAD_ABORT 82
|
||||
#define K_SYSCALL_K_THREAD_ABSOLUTE_DEADLINE_SET 83
|
||||
#define K_SYSCALL_K_THREAD_CREATE 84
|
||||
#define K_SYSCALL_K_THREAD_CUSTOM_DATA_GET 85
|
||||
#define K_SYSCALL_K_THREAD_CUSTOM_DATA_SET 86
|
||||
#define K_SYSCALL_K_THREAD_DEADLINE_SET 87
|
||||
#define K_SYSCALL_K_THREAD_JOIN 88
|
||||
#define K_SYSCALL_K_THREAD_NAME_COPY 89
|
||||
#define K_SYSCALL_K_THREAD_NAME_SET 90
|
||||
#define K_SYSCALL_K_THREAD_PRIORITY_GET 91
|
||||
#define K_SYSCALL_K_THREAD_PRIORITY_SET 92
|
||||
#define K_SYSCALL_K_THREAD_RESUME 93
|
||||
#define K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_GET 94
|
||||
#define K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_PCT_SET 95
|
||||
#define K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_SET 96
|
||||
#define K_SYSCALL_K_THREAD_STACK_ALLOC 97
|
||||
#define K_SYSCALL_K_THREAD_STACK_FREE 98
|
||||
#define K_SYSCALL_K_THREAD_STACK_SPACE_GET 99
|
||||
#define K_SYSCALL_K_THREAD_SUSPEND 100
|
||||
#define K_SYSCALL_K_THREAD_TIMEOUT_EXPIRES_TICKS 101
|
||||
#define K_SYSCALL_K_THREAD_TIMEOUT_REMAINING_TICKS 102
|
||||
#define K_SYSCALL_K_TIMER_EXPIRES_TICKS 103
|
||||
#define K_SYSCALL_K_TIMER_REMAINING_TICKS 104
|
||||
#define K_SYSCALL_K_TIMER_START 105
|
||||
#define K_SYSCALL_K_TIMER_STATUS_GET 106
|
||||
#define K_SYSCALL_K_TIMER_STATUS_SYNC 107
|
||||
#define K_SYSCALL_K_TIMER_STOP 108
|
||||
#define K_SYSCALL_K_TIMER_USER_DATA_GET 109
|
||||
#define K_SYSCALL_K_TIMER_USER_DATA_SET 110
|
||||
#define K_SYSCALL_K_UPTIME_TICKS 111
|
||||
#define K_SYSCALL_K_USLEEP 112
|
||||
#define K_SYSCALL_K_WAKEUP 113
|
||||
#define K_SYSCALL_K_YIELD 114
|
||||
#define K_SYSCALL_LOG_BUFFERED_CNT 115
|
||||
#define K_SYSCALL_LOG_FILTER_SET 116
|
||||
#define K_SYSCALL_LOG_FRONTEND_FILTER_SET 117
|
||||
#define K_SYSCALL_LOG_PANIC 118
|
||||
#define K_SYSCALL_LOG_PROCESS 119
|
||||
#define K_SYSCALL_SPI_RELEASE 120
|
||||
#define K_SYSCALL_SPI_TRANSCEIVE 121
|
||||
#define K_SYSCALL_SYS_CLOCK_GETRTOFFSET 122
|
||||
#define K_SYSCALL_SYS_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_GET 123
|
||||
#define K_SYSCALL_SYS_CLOCK_NANOSLEEP 124
|
||||
#define K_SYSCALL_SYS_CLOCK_SETTIME 125
|
||||
#define K_SYSCALL_UART_CONFIGURE 126
|
||||
#define K_SYSCALL_UART_CONFIG_GET 127
|
||||
#define K_SYSCALL_UART_DRV_CMD 128
|
||||
#define K_SYSCALL_UART_ERR_CHECK 129
|
||||
#define K_SYSCALL_UART_IRQ_ERR_DISABLE 130
|
||||
#define K_SYSCALL_UART_IRQ_ERR_ENABLE 131
|
||||
#define K_SYSCALL_UART_IRQ_IS_PENDING 132
|
||||
#define K_SYSCALL_UART_IRQ_RX_DISABLE 133
|
||||
#define K_SYSCALL_UART_IRQ_RX_ENABLE 134
|
||||
#define K_SYSCALL_UART_IRQ_TX_DISABLE 135
|
||||
#define K_SYSCALL_UART_IRQ_TX_ENABLE 136
|
||||
#define K_SYSCALL_UART_IRQ_UPDATE 137
|
||||
#define K_SYSCALL_UART_LINE_CTRL_GET 138
|
||||
#define K_SYSCALL_UART_LINE_CTRL_SET 139
|
||||
#define K_SYSCALL_UART_POLL_IN 140
|
||||
#define K_SYSCALL_UART_POLL_IN_U16 141
|
||||
#define K_SYSCALL_UART_POLL_OUT 142
|
||||
#define K_SYSCALL_UART_POLL_OUT_U16 143
|
||||
#define K_SYSCALL_UART_RX_DISABLE 144
|
||||
#define K_SYSCALL_UART_RX_ENABLE 145
|
||||
#define K_SYSCALL_UART_RX_ENABLE_U16 146
|
||||
#define K_SYSCALL_UART_TX 147
|
||||
#define K_SYSCALL_UART_TX_ABORT 148
|
||||
#define K_SYSCALL_UART_TX_U16 149
|
||||
#define K_SYSCALL_XTENSA_USER_FAULT 150
|
||||
#define K_SYSCALL_ZEPHYR_FPUTC 151
|
||||
#define K_SYSCALL_ZEPHYR_FWRITE 152
|
||||
#define K_SYSCALL_ZEPHYR_READ_STDIN 153
|
||||
#define K_SYSCALL_ZEPHYR_WRITE_STDOUT 154
|
||||
#define K_SYSCALL_Z_ERRNO 155
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0 156
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1 157
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2 158
|
||||
#define K_SYSCALL_Z_LOG_MSG_STATIC_CREATE 159
|
||||
#define K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK 160
|
||||
#define K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK 161
|
||||
#define K_SYSCALL_BAD 162
|
||||
#define K_SYSCALL_LIMIT 163
|
||||
|
||||
|
||||
/* Following syscalls are not used in image */
|
||||
#define K_SYSCALL_ADC_CHANNEL_SETUP 164
|
||||
#define K_SYSCALL_ADC_GET_DECODER 165
|
||||
#define K_SYSCALL_ADC_READ 166
|
||||
#define K_SYSCALL_ADC_READ_ASYNC 167
|
||||
#define K_SYSCALL_ATOMIC_ADD 168
|
||||
#define K_SYSCALL_ATOMIC_AND 169
|
||||
#define K_SYSCALL_ATOMIC_CAS 170
|
||||
#define K_SYSCALL_ATOMIC_NAND 171
|
||||
#define K_SYSCALL_ATOMIC_OR 172
|
||||
#define K_SYSCALL_ATOMIC_PTR_CAS 173
|
||||
#define K_SYSCALL_ATOMIC_PTR_SET 174
|
||||
#define K_SYSCALL_ATOMIC_SET 175
|
||||
#define K_SYSCALL_ATOMIC_SUB 176
|
||||
#define K_SYSCALL_ATOMIC_XOR 177
|
||||
#define K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET 178
|
||||
#define K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET 179
|
||||
#define K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET 180
|
||||
#define K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET 181
|
||||
#define K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET 182
|
||||
#define K_SYSCALL_AUXDISPLAY_CLEAR 183
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET 184
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET 185
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED 186
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET 187
|
||||
#define K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET 188
|
||||
#define K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND 189
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_OFF 190
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_ON 191
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET 192
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET 193
|
||||
#define K_SYSCALL_AUXDISPLAY_IS_BUSY 194
|
||||
#define K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED 195
|
||||
#define K_SYSCALL_AUXDISPLAY_WRITE 196
|
||||
#define K_SYSCALL_BBRAM_CHECK_INVALID 197
|
||||
#define K_SYSCALL_BBRAM_CHECK_POWER 198
|
||||
#define K_SYSCALL_BBRAM_CHECK_STANDBY_POWER 199
|
||||
#define K_SYSCALL_BBRAM_GET_SIZE 200
|
||||
#define K_SYSCALL_BBRAM_READ 201
|
||||
#define K_SYSCALL_BBRAM_WRITE 202
|
||||
#define K_SYSCALL_BC12_SET_RESULT_CB 203
|
||||
#define K_SYSCALL_BC12_SET_ROLE 204
|
||||
#define K_SYSCALL_BIOMETRIC_ATTR_GET 205
|
||||
#define K_SYSCALL_BIOMETRIC_ATTR_SET 206
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_ABORT 207
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_CAPTURE 208
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_FINALIZE 209
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_START 210
|
||||
#define K_SYSCALL_BIOMETRIC_GET_CAPABILITIES 211
|
||||
#define K_SYSCALL_BIOMETRIC_LED_CONTROL 212
|
||||
#define K_SYSCALL_BIOMETRIC_MATCH 213
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_DELETE 214
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_DELETE_ALL 215
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_LIST 216
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_READ 217
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_STORE 218
|
||||
#define K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ 219
|
||||
#define K_SYSCALL_CAN_CALC_TIMING 220
|
||||
#define K_SYSCALL_CAN_CALC_TIMING_DATA 221
|
||||
#define K_SYSCALL_CAN_GET_BITRATE_MAX 222
|
||||
#define K_SYSCALL_CAN_GET_BITRATE_MIN 223
|
||||
#define K_SYSCALL_CAN_GET_CAPABILITIES 224
|
||||
#define K_SYSCALL_CAN_GET_CORE_CLOCK 225
|
||||
#define K_SYSCALL_CAN_GET_MAX_FILTERS 226
|
||||
#define K_SYSCALL_CAN_GET_MODE 227
|
||||
#define K_SYSCALL_CAN_GET_STATE 228
|
||||
#define K_SYSCALL_CAN_GET_TIMING_DATA_MAX 229
|
||||
#define K_SYSCALL_CAN_GET_TIMING_DATA_MIN 230
|
||||
#define K_SYSCALL_CAN_GET_TIMING_MAX 231
|
||||
#define K_SYSCALL_CAN_GET_TIMING_MIN 232
|
||||
#define K_SYSCALL_CAN_GET_TRANSCEIVER 233
|
||||
#define K_SYSCALL_CAN_RECOVER 234
|
||||
#define K_SYSCALL_CAN_REMOVE_RX_FILTER 235
|
||||
#define K_SYSCALL_CAN_SEND 236
|
||||
#define K_SYSCALL_CAN_SET_BITRATE 237
|
||||
#define K_SYSCALL_CAN_SET_BITRATE_DATA 238
|
||||
#define K_SYSCALL_CAN_SET_MODE 239
|
||||
#define K_SYSCALL_CAN_SET_TIMING 240
|
||||
#define K_SYSCALL_CAN_SET_TIMING_DATA 241
|
||||
#define K_SYSCALL_CAN_START 242
|
||||
#define K_SYSCALL_CAN_STATS_GET_ACK_ERRORS 243
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS 244
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS 245
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT_ERRORS 246
|
||||
#define K_SYSCALL_CAN_STATS_GET_CRC_ERRORS 247
|
||||
#define K_SYSCALL_CAN_STATS_GET_FORM_ERRORS 248
|
||||
#define K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS 249
|
||||
#define K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS 250
|
||||
#define K_SYSCALL_CAN_STOP 251
|
||||
#define K_SYSCALL_CHARGER_CHARGE_ENABLE 252
|
||||
#define K_SYSCALL_CHARGER_GET_PROP 253
|
||||
#define K_SYSCALL_CHARGER_SET_PROP 254
|
||||
#define K_SYSCALL_COMPARATOR_GET_OUTPUT 255
|
||||
#define K_SYSCALL_COMPARATOR_SET_TRIGGER 256
|
||||
#define K_SYSCALL_COMPARATOR_TRIGGER_IS_PENDING 257
|
||||
#define K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM 258
|
||||
#define K_SYSCALL_COUNTER_GET_FREQUENCY 259
|
||||
#define K_SYSCALL_COUNTER_GET_FREQUENCY_64 260
|
||||
#define K_SYSCALL_COUNTER_GET_GUARD_PERIOD 261
|
||||
#define K_SYSCALL_COUNTER_GET_GUARD_PERIOD_64 262
|
||||
#define K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE 263
|
||||
#define K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE_64 264
|
||||
#define K_SYSCALL_COUNTER_GET_NUM_OF_CHANNELS 265
|
||||
#define K_SYSCALL_COUNTER_GET_PENDING_INT 266
|
||||
#define K_SYSCALL_COUNTER_GET_TOP_VALUE 267
|
||||
#define K_SYSCALL_COUNTER_GET_TOP_VALUE_64 268
|
||||
#define K_SYSCALL_COUNTER_GET_VALUE 269
|
||||
#define K_SYSCALL_COUNTER_GET_VALUE_64 270
|
||||
#define K_SYSCALL_COUNTER_IS_COUNTING_UP 271
|
||||
#define K_SYSCALL_COUNTER_NS_TO_TICKS 272
|
||||
#define K_SYSCALL_COUNTER_NS_TO_TICKS_64 273
|
||||
#define K_SYSCALL_COUNTER_RESET 274
|
||||
#define K_SYSCALL_COUNTER_SET_CHANNEL_ALARM 275
|
||||
#define K_SYSCALL_COUNTER_SET_CHANNEL_ALARM_64 276
|
||||
#define K_SYSCALL_COUNTER_SET_GUARD_PERIOD 277
|
||||
#define K_SYSCALL_COUNTER_SET_GUARD_PERIOD_64 278
|
||||
#define K_SYSCALL_COUNTER_SET_TOP_VALUE 279
|
||||
#define K_SYSCALL_COUNTER_SET_TOP_VALUE_64 280
|
||||
#define K_SYSCALL_COUNTER_SET_VALUE 281
|
||||
#define K_SYSCALL_COUNTER_SET_VALUE_64 282
|
||||
#define K_SYSCALL_COUNTER_START 283
|
||||
#define K_SYSCALL_COUNTER_STOP 284
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_NS 285
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_NS_64 286
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_US 287
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_US_64 288
|
||||
#define K_SYSCALL_COUNTER_US_TO_TICKS 289
|
||||
#define K_SYSCALL_COUNTER_US_TO_TICKS_64 290
|
||||
#define K_SYSCALL_CRC_BEGIN 291
|
||||
#define K_SYSCALL_CRC_FINISH 292
|
||||
#define K_SYSCALL_CRC_UPDATE 293
|
||||
#define K_SYSCALL_DAC_CHANNEL_SETUP 294
|
||||
#define K_SYSCALL_DAC_WRITE_VALUE 295
|
||||
#define K_SYSCALL_DAI_CONFIG_GET 296
|
||||
#define K_SYSCALL_DAI_CONFIG_SET 297
|
||||
#define K_SYSCALL_DAI_CONFIG_UPDATE 298
|
||||
#define K_SYSCALL_DAI_GET_PROPERTIES_COPY 299
|
||||
#define K_SYSCALL_DAI_PROBE 300
|
||||
#define K_SYSCALL_DAI_REMOVE 301
|
||||
#define K_SYSCALL_DAI_TRIGGER 302
|
||||
#define K_SYSCALL_DAI_TS_CONFIG 303
|
||||
#define K_SYSCALL_DAI_TS_GET 304
|
||||
#define K_SYSCALL_DAI_TS_START 305
|
||||
#define K_SYSCALL_DAI_TS_STOP 306
|
||||
#define K_SYSCALL_DEVMUX_SELECT_GET 307
|
||||
#define K_SYSCALL_DEVMUX_SELECT_SET 308
|
||||
#define K_SYSCALL_EEPROM_GET_SIZE 309
|
||||
#define K_SYSCALL_EEPROM_READ 310
|
||||
#define K_SYSCALL_EEPROM_WRITE 311
|
||||
#define K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF 312
|
||||
#define K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING 313
|
||||
#define K_SYSCALL_ENTROPY_GET_ENTROPY 314
|
||||
#define K_SYSCALL_ESPI_CONFIG 315
|
||||
#define K_SYSCALL_ESPI_FLASH_ERASE 316
|
||||
#define K_SYSCALL_ESPI_GET_CHANNEL_STATUS 317
|
||||
#define K_SYSCALL_ESPI_READ_FLASH 318
|
||||
#define K_SYSCALL_ESPI_READ_LPC_REQUEST 319
|
||||
#define K_SYSCALL_ESPI_READ_REQUEST 320
|
||||
#define K_SYSCALL_ESPI_RECEIVE_OOB 321
|
||||
#define K_SYSCALL_ESPI_RECEIVE_VWIRE 322
|
||||
#define K_SYSCALL_ESPI_SAF_ACTIVATE 323
|
||||
#define K_SYSCALL_ESPI_SAF_CONFIG 324
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_ERASE 325
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_READ 326
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS 327
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_WRITE 328
|
||||
#define K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS 329
|
||||
#define K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS 330
|
||||
#define K_SYSCALL_ESPI_SEND_OOB 331
|
||||
#define K_SYSCALL_ESPI_SEND_VWIRE 332
|
||||
#define K_SYSCALL_ESPI_WRITE_FLASH 333
|
||||
#define K_SYSCALL_ESPI_WRITE_LPC_REQUEST 334
|
||||
#define K_SYSCALL_ESPI_WRITE_REQUEST 335
|
||||
#define K_SYSCALL_FLASH_COPY 336
|
||||
#define K_SYSCALL_FLASH_ERASE 337
|
||||
#define K_SYSCALL_FLASH_EX_OP 338
|
||||
#define K_SYSCALL_FLASH_FILL 339
|
||||
#define K_SYSCALL_FLASH_FLATTEN 340
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_COUNT 341
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX 342
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS 343
|
||||
#define K_SYSCALL_FLASH_GET_PARAMETERS 344
|
||||
#define K_SYSCALL_FLASH_GET_SIZE 345
|
||||
#define K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE 346
|
||||
#define K_SYSCALL_FLASH_READ 347
|
||||
#define K_SYSCALL_FLASH_READ_JEDEC_ID 348
|
||||
#define K_SYSCALL_FLASH_SFDP_READ 349
|
||||
#define K_SYSCALL_FLASH_SIMULATOR_GET_MEMORY 350
|
||||
#define K_SYSCALL_FLASH_SIMULATOR_GET_PARAMS 351
|
||||
#define K_SYSCALL_FLASH_SIMULATOR_SET_CALLBACKS 352
|
||||
#define K_SYSCALL_FLASH_WRITE 353
|
||||
#define K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF 354
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP 355
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_PROP 356
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_PROPS 357
|
||||
#define K_SYSCALL_FUEL_GAUGE_SET_PROP 358
|
||||
#define K_SYSCALL_FUEL_GAUGE_SET_PROPS 359
|
||||
#define K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS 360
|
||||
#define K_SYSCALL_GNSS_GET_FIX_RATE 361
|
||||
#define K_SYSCALL_GNSS_GET_LATEST_TIMEPULSE 362
|
||||
#define K_SYSCALL_GNSS_GET_NAVIGATION_MODE 363
|
||||
#define K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS 364
|
||||
#define K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS 365
|
||||
#define K_SYSCALL_GNSS_SET_FIX_RATE 366
|
||||
#define K_SYSCALL_GNSS_SET_NAVIGATION_MODE 367
|
||||
#define K_SYSCALL_HAPTICS_START_OUTPUT 368
|
||||
#define K_SYSCALL_HAPTICS_STOP_OUTPUT 369
|
||||
#define K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE 370
|
||||
#define K_SYSCALL_HWINFO_GET_DEVICE_EUI64 371
|
||||
#define K_SYSCALL_HWINFO_GET_DEVICE_ID 372
|
||||
#define K_SYSCALL_HWINFO_GET_RESET_CAUSE 373
|
||||
#define K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE 374
|
||||
#define K_SYSCALL_I2C_CONFIGURE 375
|
||||
#define K_SYSCALL_I2C_GET_CONFIG 376
|
||||
#define K_SYSCALL_I2C_RECOVER_BUS 377
|
||||
#define K_SYSCALL_I2C_TARGET_DRIVER_REGISTER 378
|
||||
#define K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER 379
|
||||
#define K_SYSCALL_I2C_TRANSFER 380
|
||||
#define K_SYSCALL_I2S_BUF_READ 381
|
||||
#define K_SYSCALL_I2S_BUF_WRITE 382
|
||||
#define K_SYSCALL_I2S_CONFIGURE 383
|
||||
#define K_SYSCALL_I2S_TRIGGER 384
|
||||
#define K_SYSCALL_I3C_DO_CCC 385
|
||||
#define K_SYSCALL_I3C_TRANSFER 386
|
||||
#define K_SYSCALL_IPM_COMPLETE 387
|
||||
#define K_SYSCALL_IPM_MAX_DATA_SIZE_GET 388
|
||||
#define K_SYSCALL_IPM_MAX_ID_VAL_GET 389
|
||||
#define K_SYSCALL_IPM_SEND 390
|
||||
#define K_SYSCALL_IPM_SET_ENABLED 391
|
||||
#define K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS 392
|
||||
#define K_SYSCALL_IVSHMEM_GET_ID 393
|
||||
#define K_SYSCALL_IVSHMEM_GET_MAX_PEERS 394
|
||||
#define K_SYSCALL_IVSHMEM_GET_MEM 395
|
||||
#define K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION 396
|
||||
#define K_SYSCALL_IVSHMEM_GET_PROTOCOL 397
|
||||
#define K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION 398
|
||||
#define K_SYSCALL_IVSHMEM_GET_STATE 399
|
||||
#define K_SYSCALL_IVSHMEM_GET_VECTORS 400
|
||||
#define K_SYSCALL_IVSHMEM_INT_PEER 401
|
||||
#define K_SYSCALL_IVSHMEM_REGISTER_HANDLER 402
|
||||
#define K_SYSCALL_IVSHMEM_SET_STATE 403
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET 404
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET 405
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET 406
|
||||
#define K_SYSCALL_K_MEM_PAGING_STATS_GET 407
|
||||
#define K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET 408
|
||||
#define K_SYSCALL_LED_BLINK 409
|
||||
#define K_SYSCALL_LED_GET_INFO 410
|
||||
#define K_SYSCALL_LED_OFF 411
|
||||
#define K_SYSCALL_LED_ON 412
|
||||
#define K_SYSCALL_LED_SET_BRIGHTNESS 413
|
||||
#define K_SYSCALL_LED_SET_CHANNEL 414
|
||||
#define K_SYSCALL_LED_SET_COLOR 415
|
||||
#define K_SYSCALL_LED_WRITE_CHANNELS 416
|
||||
#define K_SYSCALL_LLEXT_GET_FN_TABLE 417
|
||||
#define K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT 418
|
||||
#define K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT 419
|
||||
#define K_SYSCALL_MBOX_MAX_CHANNELS_GET 420
|
||||
#define K_SYSCALL_MBOX_MTU_GET 421
|
||||
#define K_SYSCALL_MBOX_SEND 422
|
||||
#define K_SYSCALL_MBOX_SET_ENABLED 423
|
||||
#define K_SYSCALL_MDIO_READ 424
|
||||
#define K_SYSCALL_MDIO_READ_C45 425
|
||||
#define K_SYSCALL_MDIO_WRITE 426
|
||||
#define K_SYSCALL_MDIO_WRITE_C45 427
|
||||
#define K_SYSCALL_MSPI_CONFIG 428
|
||||
#define K_SYSCALL_MSPI_DEV_CONFIG 429
|
||||
#define K_SYSCALL_MSPI_GET_CHANNEL_STATUS 430
|
||||
#define K_SYSCALL_MSPI_SCRAMBLE_CONFIG 431
|
||||
#define K_SYSCALL_MSPI_TIMING_CONFIG 432
|
||||
#define K_SYSCALL_MSPI_TRANSCEIVE 433
|
||||
#define K_SYSCALL_MSPI_XIP_CONFIG 434
|
||||
#define K_SYSCALL_NET_ADDR_NTOP 435
|
||||
#define K_SYSCALL_NET_ADDR_PTON 436
|
||||
#define K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX 437
|
||||
#define K_SYSCALL_NET_IF_GET_BY_INDEX 438
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_ADD_BY_INDEX 439
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_LOOKUP_BY_INDEX 440
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX 441
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_GW_BY_INDEX 442
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_ADDR_BY_INDEX 443
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_INDEX 444
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_ADD_BY_INDEX 445
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_LOOKUP_BY_INDEX 446
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_RM_BY_INDEX 447
|
||||
#define K_SYSCALL_NET_SOCKET_SERVICE_REGISTER 448
|
||||
#define K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE 449
|
||||
#define K_SYSCALL_OPAMP_SET_GAIN 450
|
||||
#define K_SYSCALL_OTP_PROGRAM 451
|
||||
#define K_SYSCALL_OTP_READ 452
|
||||
#define K_SYSCALL_PECI_CONFIG 453
|
||||
#define K_SYSCALL_PECI_DISABLE 454
|
||||
#define K_SYSCALL_PECI_ENABLE 455
|
||||
#define K_SYSCALL_PECI_TRANSFER 456
|
||||
#define K_SYSCALL_PS2_CONFIG 457
|
||||
#define K_SYSCALL_PS2_DISABLE_CALLBACK 458
|
||||
#define K_SYSCALL_PS2_ENABLE_CALLBACK 459
|
||||
#define K_SYSCALL_PS2_READ 460
|
||||
#define K_SYSCALL_PS2_WRITE 461
|
||||
#define K_SYSCALL_PSI5_REGISTER_CALLBACK 462
|
||||
#define K_SYSCALL_PSI5_SEND 463
|
||||
#define K_SYSCALL_PSI5_START_SYNC 464
|
||||
#define K_SYSCALL_PSI5_STOP_SYNC 465
|
||||
#define K_SYSCALL_PTP_CLOCK_GET 466
|
||||
#define K_SYSCALL_PWM_CAPTURE_CYCLES 467
|
||||
#define K_SYSCALL_PWM_DISABLE_CAPTURE 468
|
||||
#define K_SYSCALL_PWM_DISABLE_DMA 469
|
||||
#define K_SYSCALL_PWM_ENABLE_CAPTURE 470
|
||||
#define K_SYSCALL_PWM_ENABLE_DMA 471
|
||||
#define K_SYSCALL_PWM_GET_CYCLES_PER_SEC 472
|
||||
#define K_SYSCALL_PWM_SET_CYCLES 473
|
||||
#define K_SYSCALL_RENESAS_ELC_DISABLE 474
|
||||
#define K_SYSCALL_RENESAS_ELC_ENABLE 475
|
||||
#define K_SYSCALL_RENESAS_ELC_LINK_BREAK 476
|
||||
#define K_SYSCALL_RENESAS_ELC_LINK_SET 477
|
||||
#define K_SYSCALL_RENESAS_ELC_SOFTWARE_EVENT_GENERATE 478
|
||||
#define K_SYSCALL_RENESAS_RA_CTSU_GROUP_CONFIGURE 479
|
||||
#define K_SYSCALL_RENESAS_RX_CTSU_GROUP_CONFIGURE 480
|
||||
#define K_SYSCALL_RESET_LINE_ASSERT 481
|
||||
#define K_SYSCALL_RESET_LINE_DEASSERT 482
|
||||
#define K_SYSCALL_RESET_LINE_TOGGLE 483
|
||||
#define K_SYSCALL_RESET_STATUS 484
|
||||
#define K_SYSCALL_RETAINED_MEM_CLEAR 485
|
||||
#define K_SYSCALL_RETAINED_MEM_READ 486
|
||||
#define K_SYSCALL_RETAINED_MEM_SIZE 487
|
||||
#define K_SYSCALL_RETAINED_MEM_WRITE 488
|
||||
#define K_SYSCALL_RTC_ALARM_GET_SUPPORTED_FIELDS 489
|
||||
#define K_SYSCALL_RTC_ALARM_GET_TIME 490
|
||||
#define K_SYSCALL_RTC_ALARM_IS_PENDING 491
|
||||
#define K_SYSCALL_RTC_ALARM_SET_TIME 492
|
||||
#define K_SYSCALL_RTC_GET_CALIBRATION 493
|
||||
#define K_SYSCALL_RTC_GET_TIME 494
|
||||
#define K_SYSCALL_RTC_SET_CALIBRATION 495
|
||||
#define K_SYSCALL_RTC_SET_TIME 496
|
||||
#define K_SYSCALL_RTIO_CQE_COPY_OUT 497
|
||||
#define K_SYSCALL_RTIO_CQE_GET_MEMPOOL_BUFFER 498
|
||||
#define K_SYSCALL_RTIO_POOL_ACQUIRE 499
|
||||
#define K_SYSCALL_RTIO_POOL_RELEASE 500
|
||||
#define K_SYSCALL_RTIO_RELEASE_BUFFER 501
|
||||
#define K_SYSCALL_RTIO_SQE_CANCEL 502
|
||||
#define K_SYSCALL_RTIO_SQE_COPY_IN_GET_HANDLES 503
|
||||
#define K_SYSCALL_RTIO_SQE_SIGNAL 504
|
||||
#define K_SYSCALL_RTIO_SUBMIT 505
|
||||
#define K_SYSCALL_SDHC_CARD_BUSY 506
|
||||
#define K_SYSCALL_SDHC_CARD_PRESENT 507
|
||||
#define K_SYSCALL_SDHC_DISABLE_INTERRUPT 508
|
||||
#define K_SYSCALL_SDHC_ENABLE_INTERRUPT 509
|
||||
#define K_SYSCALL_SDHC_EXECUTE_TUNING 510
|
||||
#define K_SYSCALL_SDHC_GET_HOST_PROPS 511
|
||||
#define K_SYSCALL_SDHC_HW_RESET 512
|
||||
#define K_SYSCALL_SDHC_REQUEST 513
|
||||
#define K_SYSCALL_SDHC_SET_IO 514
|
||||
#define K_SYSCALL_SENSOR_ATTR_GET 515
|
||||
#define K_SYSCALL_SENSOR_ATTR_SET 516
|
||||
#define K_SYSCALL_SENSOR_CHANNEL_GET 517
|
||||
#define K_SYSCALL_SENSOR_GET_DECODER 518
|
||||
#define K_SYSCALL_SENSOR_RECONFIGURE_READ_IODEV 519
|
||||
#define K_SYSCALL_SENSOR_SAMPLE_FETCH 520
|
||||
#define K_SYSCALL_SENSOR_SAMPLE_FETCH_CHAN 521
|
||||
#define K_SYSCALL_SENT_REGISTER_CALLBACK 522
|
||||
#define K_SYSCALL_SENT_START_LISTENING 523
|
||||
#define K_SYSCALL_SENT_STOP_LISTENING 524
|
||||
#define K_SYSCALL_SIP_SUPERVISORY_CALL 525
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_REQ 526
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_RES 527
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FORMAT_TRANS_ID 528
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FREE_ASYNC_MEMORY 529
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FUNC_ID_VALID 530
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_GET_ERROR_CODE 531
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_GET_TRANS_IDX 532
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_UPDATE_TRANS_ID 533
|
||||
#define K_SYSCALL_SMBUS_BLOCK_PCALL 534
|
||||
#define K_SYSCALL_SMBUS_BLOCK_READ 535
|
||||
#define K_SYSCALL_SMBUS_BLOCK_WRITE 536
|
||||
#define K_SYSCALL_SMBUS_BYTE_DATA_READ 537
|
||||
#define K_SYSCALL_SMBUS_BYTE_DATA_WRITE 538
|
||||
#define K_SYSCALL_SMBUS_BYTE_READ 539
|
||||
#define K_SYSCALL_SMBUS_BYTE_WRITE 540
|
||||
#define K_SYSCALL_SMBUS_CONFIGURE 541
|
||||
#define K_SYSCALL_SMBUS_GET_CONFIG 542
|
||||
#define K_SYSCALL_SMBUS_HOST_NOTIFY_REMOVE_CB 543
|
||||
#define K_SYSCALL_SMBUS_PCALL 544
|
||||
#define K_SYSCALL_SMBUS_QUICK 545
|
||||
#define K_SYSCALL_SMBUS_SMBALERT_REMOVE_CB 546
|
||||
#define K_SYSCALL_SMBUS_WORD_DATA_READ 547
|
||||
#define K_SYSCALL_SMBUS_WORD_DATA_WRITE 548
|
||||
#define K_SYSCALL_STEPPER_CTRL_CONFIGURE_RAMP 549
|
||||
#define K_SYSCALL_STEPPER_CTRL_GET_ACTUAL_POSITION 550
|
||||
#define K_SYSCALL_STEPPER_CTRL_IS_MOVING 551
|
||||
#define K_SYSCALL_STEPPER_CTRL_MOVE_BY 552
|
||||
#define K_SYSCALL_STEPPER_CTRL_MOVE_TO 553
|
||||
#define K_SYSCALL_STEPPER_CTRL_RUN 554
|
||||
#define K_SYSCALL_STEPPER_CTRL_SET_EVENT_CB 555
|
||||
#define K_SYSCALL_STEPPER_CTRL_SET_MICROSTEP_INTERVAL 556
|
||||
#define K_SYSCALL_STEPPER_CTRL_SET_REFERENCE_POSITION 557
|
||||
#define K_SYSCALL_STEPPER_CTRL_STOP 558
|
||||
#define K_SYSCALL_STEPPER_DISABLE 559
|
||||
#define K_SYSCALL_STEPPER_ENABLE 560
|
||||
#define K_SYSCALL_STEPPER_GET_MICRO_STEP_RES 561
|
||||
#define K_SYSCALL_STEPPER_SET_EVENT_CB 562
|
||||
#define K_SYSCALL_STEPPER_SET_MICRO_STEP_RES 563
|
||||
#define K_SYSCALL_SWDP_CONFIGURE 564
|
||||
#define K_SYSCALL_SWDP_GET_PINS 565
|
||||
#define K_SYSCALL_SWDP_INPUT_SEQUENCE 566
|
||||
#define K_SYSCALL_SWDP_OUTPUT_SEQUENCE 567
|
||||
#define K_SYSCALL_SWDP_PORT_OFF 568
|
||||
#define K_SYSCALL_SWDP_PORT_ON 569
|
||||
#define K_SYSCALL_SWDP_SET_CLOCK 570
|
||||
#define K_SYSCALL_SWDP_SET_PINS 571
|
||||
#define K_SYSCALL_SWDP_TRANSFER 572
|
||||
#define K_SYSCALL_SYSCON_GET_BASE 573
|
||||
#define K_SYSCALL_SYSCON_GET_SIZE 574
|
||||
#define K_SYSCALL_SYSCON_READ_REG 575
|
||||
#define K_SYSCALL_SYSCON_WRITE_REG 576
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE 577
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE 578
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE 579
|
||||
#define K_SYSCALL_SYS_CSRAND_GET 580
|
||||
#define K_SYSCALL_SYS_RAND_GET 581
|
||||
#define K_SYSCALL_TEE_CANCEL 582
|
||||
#define K_SYSCALL_TEE_CLOSE_SESSION 583
|
||||
#define K_SYSCALL_TEE_GET_VERSION 584
|
||||
#define K_SYSCALL_TEE_INVOKE_FUNC 585
|
||||
#define K_SYSCALL_TEE_OPEN_SESSION 586
|
||||
#define K_SYSCALL_TEE_SHM_ALLOC 587
|
||||
#define K_SYSCALL_TEE_SHM_FREE 588
|
||||
#define K_SYSCALL_TEE_SHM_REGISTER 589
|
||||
#define K_SYSCALL_TEE_SHM_UNREGISTER 590
|
||||
#define K_SYSCALL_TEE_SUPPL_RECV 591
|
||||
#define K_SYSCALL_TEE_SUPPL_SEND 592
|
||||
#define K_SYSCALL_TGPIO_PIN_CONFIG_EXT_TIMESTAMP 593
|
||||
#define K_SYSCALL_TGPIO_PIN_DISABLE 594
|
||||
#define K_SYSCALL_TGPIO_PIN_PERIODIC_OUTPUT 595
|
||||
#define K_SYSCALL_TGPIO_PIN_READ_TS_EC 596
|
||||
#define K_SYSCALL_TGPIO_PORT_GET_CYCLES_PER_SECOND 597
|
||||
#define K_SYSCALL_TGPIO_PORT_GET_TIME 598
|
||||
#define K_SYSCALL_UPDATEHUB_AUTOHANDLER 599
|
||||
#define K_SYSCALL_UPDATEHUB_CONFIRM 600
|
||||
#define K_SYSCALL_UPDATEHUB_PROBE 601
|
||||
#define K_SYSCALL_UPDATEHUB_REBOOT 602
|
||||
#define K_SYSCALL_UPDATEHUB_REPORT_ERROR 603
|
||||
#define K_SYSCALL_UPDATEHUB_UPDATE 604
|
||||
#define K_SYSCALL_USER_FAULT 605
|
||||
#define K_SYSCALL_W1_CHANGE_BUS_LOCK 606
|
||||
#define K_SYSCALL_W1_CONFIGURE 607
|
||||
#define K_SYSCALL_W1_GET_SLAVE_COUNT 608
|
||||
#define K_SYSCALL_W1_READ_BIT 609
|
||||
#define K_SYSCALL_W1_READ_BLOCK 610
|
||||
#define K_SYSCALL_W1_READ_BYTE 611
|
||||
#define K_SYSCALL_W1_RESET_BUS 612
|
||||
#define K_SYSCALL_W1_SEARCH_BUS 613
|
||||
#define K_SYSCALL_W1_WRITE_BIT 614
|
||||
#define K_SYSCALL_W1_WRITE_BLOCK 615
|
||||
#define K_SYSCALL_W1_WRITE_BYTE 616
|
||||
#define K_SYSCALL_WDT_DISABLE 617
|
||||
#define K_SYSCALL_WDT_FEED 618
|
||||
#define K_SYSCALL_WDT_SETUP 619
|
||||
#define K_SYSCALL_ZSOCK_ACCEPT 620
|
||||
#define K_SYSCALL_ZSOCK_BIND 621
|
||||
#define K_SYSCALL_ZSOCK_CLOSE 622
|
||||
#define K_SYSCALL_ZSOCK_CONNECT 623
|
||||
#define K_SYSCALL_ZSOCK_FCNTL_IMPL 624
|
||||
#define K_SYSCALL_ZSOCK_GETHOSTNAME 625
|
||||
#define K_SYSCALL_ZSOCK_GETPEERNAME 626
|
||||
#define K_SYSCALL_ZSOCK_GETSOCKNAME 627
|
||||
#define K_SYSCALL_ZSOCK_GETSOCKOPT 628
|
||||
#define K_SYSCALL_ZSOCK_GET_CONTEXT_OBJECT 629
|
||||
#define K_SYSCALL_ZSOCK_INET_PTON 630
|
||||
#define K_SYSCALL_ZSOCK_IOCTL_IMPL 631
|
||||
#define K_SYSCALL_ZSOCK_LISTEN 632
|
||||
#define K_SYSCALL_ZSOCK_RECVFROM 633
|
||||
#define K_SYSCALL_ZSOCK_RECVMSG 634
|
||||
#define K_SYSCALL_ZSOCK_SENDMSG 635
|
||||
#define K_SYSCALL_ZSOCK_SENDTO 636
|
||||
#define K_SYSCALL_ZSOCK_SETSOCKOPT 637
|
||||
#define K_SYSCALL_ZSOCK_SHUTDOWN 638
|
||||
#define K_SYSCALL_ZSOCK_SOCKET 639
|
||||
#define K_SYSCALL_ZSOCK_SOCKETPAIR 640
|
||||
#define K_SYSCALL_ZVFS_POLL 641
|
||||
#define K_SYSCALL_ZVFS_SELECT 642
|
||||
#define K_SYSCALL_Z_ZSOCK_GETADDRINFO_INTERNAL 643
|
||||
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#endif /* _ASMLANGUAGE */
|
||||
|
||||
#endif /* ZEPHYR_SYSCALL_LIST_H */
|
||||
125
build/zephyr/include/generated/zephyr/syscalls/adc.h
Normal file
125
build/zephyr/include/generated/zephyr/syscalls/adc.h
Normal file
@@ -0,0 +1,125 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ADC_H
|
||||
#define Z_INCLUDE_SYSCALLS_ADC_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_adc_channel_setup(const struct device * dev, const struct adc_channel_cfg * channel_cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int adc_channel_setup(const struct device * dev, const struct adc_channel_cfg * channel_cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct adc_channel_cfg * val; } parm1 = { .val = channel_cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ADC_CHANNEL_SETUP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_adc_channel_setup(dev, channel_cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define adc_channel_setup(dev, channel_cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ADC_CHANNEL_SETUP, adc_channel_setup, dev, channel_cfg); syscall__retval = adc_channel_setup(dev, channel_cfg); sys_port_trace_syscall_exit(K_SYSCALL_ADC_CHANNEL_SETUP, adc_channel_setup, dev, channel_cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_adc_read(const struct device * dev, const struct adc_sequence * sequence);
|
||||
|
||||
__pinned_func
|
||||
static inline int adc_read(const struct device * dev, const struct adc_sequence * sequence)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct adc_sequence * val; } parm1 = { .val = sequence };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ADC_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_adc_read(dev, sequence);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define adc_read(dev, sequence) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ADC_READ, adc_read, dev, sequence); syscall__retval = adc_read(dev, sequence); sys_port_trace_syscall_exit(K_SYSCALL_ADC_READ, adc_read, dev, sequence, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_adc_read_async(const struct device * dev, const struct adc_sequence * sequence, struct k_poll_signal * async);
|
||||
|
||||
__pinned_func
|
||||
static inline int adc_read_async(const struct device * dev, const struct adc_sequence * sequence, struct k_poll_signal * async)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct adc_sequence * val; } parm1 = { .val = sequence };
|
||||
union { uintptr_t x; struct k_poll_signal * val; } parm2 = { .val = async };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ADC_READ_ASYNC);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_adc_read_async(dev, sequence, async);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define adc_read_async(dev, sequence, async) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ADC_READ_ASYNC, adc_read_async, dev, sequence, async); syscall__retval = adc_read_async(dev, sequence, async); sys_port_trace_syscall_exit(K_SYSCALL_ADC_READ_ASYNC, adc_read_async, dev, sequence, async, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_adc_get_decoder(const struct device * dev, const struct adc_decoder_api ** api);
|
||||
|
||||
__pinned_func
|
||||
static inline int adc_get_decoder(const struct device * dev, const struct adc_decoder_api ** api)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct adc_decoder_api ** val; } parm1 = { .val = api };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ADC_GET_DECODER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_adc_get_decoder(dev, api);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define adc_get_decoder(dev, api) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ADC_GET_DECODER, adc_get_decoder, dev, api); syscall__retval = adc_get_decoder(dev, api); sys_port_trace_syscall_exit(K_SYSCALL_ADC_GET_DECODER, adc_get_decoder, dev, api, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
52
build/zephyr/include/generated/zephyr/syscalls/arch.h
Normal file
52
build/zephyr/include/generated/zephyr/syscalls/arch.h
Normal file
@@ -0,0 +1,52 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ARCH_H
|
||||
#define Z_INCLUDE_SYSCALLS_ARCH_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_xtensa_user_fault(unsigned int reason);
|
||||
|
||||
__pinned_func
|
||||
static inline void xtensa_user_fault(unsigned int reason)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; unsigned int val; } parm0 = { .val = reason };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_XTENSA_USER_FAULT);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_xtensa_user_fault(reason);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define xtensa_user_fault(reason) do { sys_port_trace_syscall_enter(K_SYSCALL_XTENSA_USER_FAULT, xtensa_user_fault, reason); xtensa_user_fault(reason); sys_port_trace_syscall_exit(K_SYSCALL_XTENSA_USER_FAULT, xtensa_user_fault, reason); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
270
build/zephyr/include/generated/zephyr/syscalls/atomic_c.h
Normal file
270
build/zephyr/include/generated/zephyr/syscalls/atomic_c.h
Normal file
@@ -0,0 +1,270 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ATOMIC_C_H
|
||||
#define Z_INCLUDE_SYSCALLS_ATOMIC_C_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern bool z_impl_atomic_cas(atomic_t * target, atomic_val_t old_value, atomic_val_t new_value);
|
||||
|
||||
__pinned_func
|
||||
static inline bool atomic_cas(atomic_t * target, atomic_val_t old_value, atomic_val_t new_value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = old_value };
|
||||
union { uintptr_t x; atomic_val_t val; } parm2 = { .val = new_value };
|
||||
return (bool) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ATOMIC_CAS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_cas(target, old_value, new_value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_cas(target, old_value, new_value) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_CAS, atomic_cas, target, old_value, new_value); syscall__retval = atomic_cas(target, old_value, new_value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_CAS, atomic_cas, target, old_value, new_value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_atomic_ptr_cas(atomic_ptr_t * target, atomic_ptr_val_t old_value, atomic_ptr_val_t new_value);
|
||||
|
||||
__pinned_func
|
||||
static inline bool atomic_ptr_cas(atomic_ptr_t * target, atomic_ptr_val_t old_value, atomic_ptr_val_t new_value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_ptr_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_ptr_val_t val; } parm1 = { .val = old_value };
|
||||
union { uintptr_t x; atomic_ptr_val_t val; } parm2 = { .val = new_value };
|
||||
return (bool) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ATOMIC_PTR_CAS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_ptr_cas(target, old_value, new_value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_ptr_cas(target, old_value, new_value) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_PTR_CAS, atomic_ptr_cas, target, old_value, new_value); syscall__retval = atomic_ptr_cas(target, old_value, new_value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_PTR_CAS, atomic_ptr_cas, target, old_value, new_value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_val_t z_impl_atomic_add(atomic_t * target, atomic_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_val_t atomic_add(atomic_t * target, atomic_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_ADD);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_add(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_add(target, value) ({ atomic_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_ADD, atomic_add, target, value); syscall__retval = atomic_add(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_ADD, atomic_add, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_val_t z_impl_atomic_sub(atomic_t * target, atomic_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_val_t atomic_sub(atomic_t * target, atomic_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_SUB);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_sub(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_sub(target, value) ({ atomic_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_SUB, atomic_sub, target, value); syscall__retval = atomic_sub(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_SUB, atomic_sub, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_val_t z_impl_atomic_set(atomic_t * target, atomic_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_val_t atomic_set(atomic_t * target, atomic_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_set(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_set(target, value) ({ atomic_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_SET, atomic_set, target, value); syscall__retval = atomic_set(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_SET, atomic_set, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_ptr_val_t z_impl_atomic_ptr_set(atomic_ptr_t * target, atomic_ptr_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_ptr_val_t atomic_ptr_set(atomic_ptr_t * target, atomic_ptr_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_ptr_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_ptr_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_ptr_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_PTR_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_ptr_set(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_ptr_set(target, value) ({ atomic_ptr_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_PTR_SET, atomic_ptr_set, target, value); syscall__retval = atomic_ptr_set(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_PTR_SET, atomic_ptr_set, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_val_t z_impl_atomic_or(atomic_t * target, atomic_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_val_t atomic_or(atomic_t * target, atomic_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_OR);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_or(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_or(target, value) ({ atomic_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_OR, atomic_or, target, value); syscall__retval = atomic_or(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_OR, atomic_or, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_val_t z_impl_atomic_xor(atomic_t * target, atomic_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_val_t atomic_xor(atomic_t * target, atomic_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_XOR);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_xor(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_xor(target, value) ({ atomic_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_XOR, atomic_xor, target, value); syscall__retval = atomic_xor(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_XOR, atomic_xor, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_val_t z_impl_atomic_and(atomic_t * target, atomic_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_val_t atomic_and(atomic_t * target, atomic_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_AND);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_and(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_and(target, value) ({ atomic_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_AND, atomic_and, target, value); syscall__retval = atomic_and(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_AND, atomic_and, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_val_t z_impl_atomic_nand(atomic_t * target, atomic_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_val_t atomic_nand(atomic_t * target, atomic_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_NAND);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_nand(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_nand(target, value) ({ atomic_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_NAND, atomic_nand, target, value); syscall__retval = atomic_nand(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_NAND, atomic_nand, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
488
build/zephyr/include/generated/zephyr/syscalls/auxdisplay.h
Normal file
488
build/zephyr/include/generated/zephyr/syscalls/auxdisplay.h
Normal file
@@ -0,0 +1,488 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_AUXDISPLAY_H
|
||||
#define Z_INCLUDE_SYSCALLS_AUXDISPLAY_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_auxdisplay_display_on(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_display_on(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_AUXDISPLAY_DISPLAY_ON);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_display_on(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_display_on(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_DISPLAY_ON, auxdisplay_display_on, dev); syscall__retval = auxdisplay_display_on(dev); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_DISPLAY_ON, auxdisplay_display_on, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_display_off(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_display_off(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_AUXDISPLAY_DISPLAY_OFF);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_display_off(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_display_off(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_DISPLAY_OFF, auxdisplay_display_off, dev); syscall__retval = auxdisplay_display_off(dev); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_DISPLAY_OFF, auxdisplay_display_off, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_cursor_set_enabled(const struct device * dev, bool enabled);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_cursor_set_enabled(const struct device * dev, bool enabled)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; bool val; } parm1 = { .val = enabled };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_cursor_set_enabled(dev, enabled);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_cursor_set_enabled(dev, enabled) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED, auxdisplay_cursor_set_enabled, dev, enabled); syscall__retval = auxdisplay_cursor_set_enabled(dev, enabled); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED, auxdisplay_cursor_set_enabled, dev, enabled, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_position_blinking_set_enabled(const struct device * dev, bool enabled);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_position_blinking_set_enabled(const struct device * dev, bool enabled)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; bool val; } parm1 = { .val = enabled };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_position_blinking_set_enabled(dev, enabled);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_position_blinking_set_enabled(dev, enabled) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED, auxdisplay_position_blinking_set_enabled, dev, enabled); syscall__retval = auxdisplay_position_blinking_set_enabled(dev, enabled); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED, auxdisplay_position_blinking_set_enabled, dev, enabled, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_cursor_shift_set(const struct device * dev, uint8_t direction, bool display_shift);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_cursor_shift_set(const struct device * dev, uint8_t direction, bool display_shift)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = direction };
|
||||
union { uintptr_t x; bool val; } parm2 = { .val = display_shift };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_cursor_shift_set(dev, direction, display_shift);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_cursor_shift_set(dev, direction, display_shift) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET, auxdisplay_cursor_shift_set, dev, direction, display_shift); syscall__retval = auxdisplay_cursor_shift_set(dev, direction, display_shift); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET, auxdisplay_cursor_shift_set, dev, direction, display_shift, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_cursor_position_set(const struct device * dev, enum auxdisplay_position type, int16_t x, int16_t y);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_cursor_position_set(const struct device * dev, enum auxdisplay_position type, int16_t x, int16_t y)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum auxdisplay_position val; } parm1 = { .val = type };
|
||||
union { uintptr_t x; int16_t val; } parm2 = { .val = x };
|
||||
union { uintptr_t x; int16_t val; } parm3 = { .val = y };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_cursor_position_set(dev, type, x, y);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_cursor_position_set(dev, type, x, y) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET, auxdisplay_cursor_position_set, dev, type, x, y); syscall__retval = auxdisplay_cursor_position_set(dev, type, x, y); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET, auxdisplay_cursor_position_set, dev, type, x, y, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_cursor_position_get(const struct device * dev, int16_t * x, int16_t * y);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_cursor_position_get(const struct device * dev, int16_t * x, int16_t * y)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; int16_t * val; } parm1 = { .val = x };
|
||||
union { uintptr_t x; int16_t * val; } parm2 = { .val = y };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_cursor_position_get(dev, x, y);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_cursor_position_get(dev, x, y) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET, auxdisplay_cursor_position_get, dev, x, y); syscall__retval = auxdisplay_cursor_position_get(dev, x, y); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET, auxdisplay_cursor_position_get, dev, x, y, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_display_position_set(const struct device * dev, enum auxdisplay_position type, int16_t x, int16_t y);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_display_position_set(const struct device * dev, enum auxdisplay_position type, int16_t x, int16_t y)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum auxdisplay_position val; } parm1 = { .val = type };
|
||||
union { uintptr_t x; int16_t val; } parm2 = { .val = x };
|
||||
union { uintptr_t x; int16_t val; } parm3 = { .val = y };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_display_position_set(dev, type, x, y);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_display_position_set(dev, type, x, y) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET, auxdisplay_display_position_set, dev, type, x, y); syscall__retval = auxdisplay_display_position_set(dev, type, x, y); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET, auxdisplay_display_position_set, dev, type, x, y, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_display_position_get(const struct device * dev, int16_t * x, int16_t * y);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_display_position_get(const struct device * dev, int16_t * x, int16_t * y)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; int16_t * val; } parm1 = { .val = x };
|
||||
union { uintptr_t x; int16_t * val; } parm2 = { .val = y };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_display_position_get(dev, x, y);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_display_position_get(dev, x, y) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET, auxdisplay_display_position_get, dev, x, y); syscall__retval = auxdisplay_display_position_get(dev, x, y); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET, auxdisplay_display_position_get, dev, x, y, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_capabilities_get(const struct device * dev, struct auxdisplay_capabilities * capabilities);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_capabilities_get(const struct device * dev, struct auxdisplay_capabilities * capabilities)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct auxdisplay_capabilities * val; } parm1 = { .val = capabilities };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_capabilities_get(dev, capabilities);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_capabilities_get(dev, capabilities) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET, auxdisplay_capabilities_get, dev, capabilities); syscall__retval = auxdisplay_capabilities_get(dev, capabilities); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET, auxdisplay_capabilities_get, dev, capabilities, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_clear(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_clear(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_AUXDISPLAY_CLEAR);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_clear(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_clear(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CLEAR, auxdisplay_clear, dev); syscall__retval = auxdisplay_clear(dev); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CLEAR, auxdisplay_clear, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_brightness_get(const struct device * dev, uint8_t * brightness);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_brightness_get(const struct device * dev, uint8_t * brightness)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t * val; } parm1 = { .val = brightness };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_brightness_get(dev, brightness);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_brightness_get(dev, brightness) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET, auxdisplay_brightness_get, dev, brightness); syscall__retval = auxdisplay_brightness_get(dev, brightness); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET, auxdisplay_brightness_get, dev, brightness, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_brightness_set(const struct device * dev, uint8_t brightness);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_brightness_set(const struct device * dev, uint8_t brightness)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = brightness };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_brightness_set(dev, brightness);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_brightness_set(dev, brightness) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET, auxdisplay_brightness_set, dev, brightness); syscall__retval = auxdisplay_brightness_set(dev, brightness); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET, auxdisplay_brightness_set, dev, brightness, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_backlight_get(const struct device * dev, uint8_t * backlight);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_backlight_get(const struct device * dev, uint8_t * backlight)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t * val; } parm1 = { .val = backlight };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_backlight_get(dev, backlight);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_backlight_get(dev, backlight) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET, auxdisplay_backlight_get, dev, backlight); syscall__retval = auxdisplay_backlight_get(dev, backlight); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET, auxdisplay_backlight_get, dev, backlight, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_backlight_set(const struct device * dev, uint8_t backlight);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_backlight_set(const struct device * dev, uint8_t backlight)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = backlight };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_backlight_set(dev, backlight);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_backlight_set(dev, backlight) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET, auxdisplay_backlight_set, dev, backlight); syscall__retval = auxdisplay_backlight_set(dev, backlight); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET, auxdisplay_backlight_set, dev, backlight, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_is_busy(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_is_busy(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_AUXDISPLAY_IS_BUSY);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_is_busy(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_is_busy(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_IS_BUSY, auxdisplay_is_busy, dev); syscall__retval = auxdisplay_is_busy(dev); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_IS_BUSY, auxdisplay_is_busy, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_custom_character_set(const struct device * dev, struct auxdisplay_character * character);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_custom_character_set(const struct device * dev, struct auxdisplay_character * character)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct auxdisplay_character * val; } parm1 = { .val = character };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_custom_character_set(dev, character);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_custom_character_set(dev, character) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET, auxdisplay_custom_character_set, dev, character); syscall__retval = auxdisplay_custom_character_set(dev, character); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET, auxdisplay_custom_character_set, dev, character, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_write(const struct device * dev, const uint8_t * data, uint16_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_write(const struct device * dev, const uint8_t * data, uint16_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const uint8_t * val; } parm1 = { .val = data };
|
||||
union { uintptr_t x; uint16_t val; } parm2 = { .val = len };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_AUXDISPLAY_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_write(dev, data, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_write(dev, data, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_WRITE, auxdisplay_write, dev, data, len); syscall__retval = auxdisplay_write(dev, data, len); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_WRITE, auxdisplay_write, dev, data, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_custom_command(const struct device * dev, struct auxdisplay_custom_data * data);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_custom_command(const struct device * dev, struct auxdisplay_custom_data * data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct auxdisplay_custom_data * val; } parm1 = { .val = data };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_custom_command(dev, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_custom_command(dev, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND, auxdisplay_custom_command, dev, data); syscall__retval = auxdisplay_custom_command(dev, data); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND, auxdisplay_custom_command, dev, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
173
build/zephyr/include/generated/zephyr/syscalls/bbram.h
Normal file
173
build/zephyr/include/generated/zephyr/syscalls/bbram.h
Normal file
@@ -0,0 +1,173 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_BBRAM_H
|
||||
#define Z_INCLUDE_SYSCALLS_BBRAM_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_bbram_check_invalid(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int bbram_check_invalid(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_BBRAM_CHECK_INVALID);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_bbram_check_invalid(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define bbram_check_invalid(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_CHECK_INVALID, bbram_check_invalid, dev); syscall__retval = bbram_check_invalid(dev); sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_CHECK_INVALID, bbram_check_invalid, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_bbram_check_standby_power(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int bbram_check_standby_power(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_BBRAM_CHECK_STANDBY_POWER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_bbram_check_standby_power(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define bbram_check_standby_power(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_CHECK_STANDBY_POWER, bbram_check_standby_power, dev); syscall__retval = bbram_check_standby_power(dev); sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_CHECK_STANDBY_POWER, bbram_check_standby_power, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_bbram_check_power(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int bbram_check_power(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_BBRAM_CHECK_POWER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_bbram_check_power(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define bbram_check_power(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_CHECK_POWER, bbram_check_power, dev); syscall__retval = bbram_check_power(dev); sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_CHECK_POWER, bbram_check_power, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_bbram_get_size(const struct device * dev, size_t * size);
|
||||
|
||||
__pinned_func
|
||||
static inline int bbram_get_size(const struct device * dev, size_t * size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; size_t * val; } parm1 = { .val = size };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_BBRAM_GET_SIZE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_bbram_get_size(dev, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define bbram_get_size(dev, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_GET_SIZE, bbram_get_size, dev, size); syscall__retval = bbram_get_size(dev, size); sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_GET_SIZE, bbram_get_size, dev, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_bbram_read(const struct device * dev, size_t offset, size_t size, uint8_t * data);
|
||||
|
||||
__pinned_func
|
||||
static inline int bbram_read(const struct device * dev, size_t offset, size_t size, uint8_t * data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = size };
|
||||
union { uintptr_t x; uint8_t * val; } parm3 = { .val = data };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_BBRAM_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_bbram_read(dev, offset, size, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define bbram_read(dev, offset, size, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_READ, bbram_read, dev, offset, size, data); syscall__retval = bbram_read(dev, offset, size, data); sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_READ, bbram_read, dev, offset, size, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_bbram_write(const struct device * dev, size_t offset, size_t size, const uint8_t * data);
|
||||
|
||||
__pinned_func
|
||||
static inline int bbram_write(const struct device * dev, size_t offset, size_t size, const uint8_t * data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = size };
|
||||
union { uintptr_t x; const uint8_t * val; } parm3 = { .val = data };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_BBRAM_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_bbram_write(dev, offset, size, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define bbram_write(dev, offset, size, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_WRITE, bbram_write, dev, offset, size, data); syscall__retval = bbram_write(dev, offset, size, data); sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_WRITE, bbram_write, dev, offset, size, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
373
build/zephyr/include/generated/zephyr/syscalls/biometrics.h
Normal file
373
build/zephyr/include/generated/zephyr/syscalls/biometrics.h
Normal file
@@ -0,0 +1,373 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_BIOMETRICS_H
|
||||
#define Z_INCLUDE_SYSCALLS_BIOMETRICS_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_biometric_get_capabilities(const struct device * dev, struct biometric_capabilities * caps);
|
||||
|
||||
__pinned_func
|
||||
static inline int biometric_get_capabilities(const struct device * dev, struct biometric_capabilities * caps)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct biometric_capabilities * val; } parm1 = { .val = caps };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_BIOMETRIC_GET_CAPABILITIES);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_biometric_get_capabilities(dev, caps);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define biometric_get_capabilities(dev, caps) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BIOMETRIC_GET_CAPABILITIES, biometric_get_capabilities, dev, caps); syscall__retval = biometric_get_capabilities(dev, caps); sys_port_trace_syscall_exit(K_SYSCALL_BIOMETRIC_GET_CAPABILITIES, biometric_get_capabilities, dev, caps, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_biometric_attr_set(const struct device * dev, enum biometric_attribute attr, int32_t val);
|
||||
|
||||
__pinned_func
|
||||
static inline int biometric_attr_set(const struct device * dev, enum biometric_attribute attr, int32_t val)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum biometric_attribute val; } parm1 = { .val = attr };
|
||||
union { uintptr_t x; int32_t val; } parm2 = { .val = val };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_BIOMETRIC_ATTR_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_biometric_attr_set(dev, attr, val);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define biometric_attr_set(dev, attr, val) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BIOMETRIC_ATTR_SET, biometric_attr_set, dev, attr, val); syscall__retval = biometric_attr_set(dev, attr, val); sys_port_trace_syscall_exit(K_SYSCALL_BIOMETRIC_ATTR_SET, biometric_attr_set, dev, attr, val, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_biometric_attr_get(const struct device * dev, enum biometric_attribute attr, int32_t * val);
|
||||
|
||||
__pinned_func
|
||||
static inline int biometric_attr_get(const struct device * dev, enum biometric_attribute attr, int32_t * val)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum biometric_attribute val; } parm1 = { .val = attr };
|
||||
union { uintptr_t x; int32_t * val; } parm2 = { .val = val };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_BIOMETRIC_ATTR_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_biometric_attr_get(dev, attr, val);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define biometric_attr_get(dev, attr, val) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BIOMETRIC_ATTR_GET, biometric_attr_get, dev, attr, val); syscall__retval = biometric_attr_get(dev, attr, val); sys_port_trace_syscall_exit(K_SYSCALL_BIOMETRIC_ATTR_GET, biometric_attr_get, dev, attr, val, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_biometric_enroll_start(const struct device * dev, uint16_t template_id);
|
||||
|
||||
__pinned_func
|
||||
static inline int biometric_enroll_start(const struct device * dev, uint16_t template_id)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint16_t val; } parm1 = { .val = template_id };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_BIOMETRIC_ENROLL_START);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_biometric_enroll_start(dev, template_id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define biometric_enroll_start(dev, template_id) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BIOMETRIC_ENROLL_START, biometric_enroll_start, dev, template_id); syscall__retval = biometric_enroll_start(dev, template_id); sys_port_trace_syscall_exit(K_SYSCALL_BIOMETRIC_ENROLL_START, biometric_enroll_start, dev, template_id, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_biometric_enroll_capture(const struct device * dev, k_timeout_t timeout, struct biometric_capture_result * result);
|
||||
|
||||
__pinned_func
|
||||
static inline int biometric_enroll_capture(const struct device * dev, k_timeout_t timeout, struct biometric_capture_result * result)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm1 = { .val = timeout };
|
||||
union { uintptr_t x; struct biometric_capture_result * val; } parm2 = { .val = result };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.split.lo, parm1.split.hi, parm2.x, K_SYSCALL_BIOMETRIC_ENROLL_CAPTURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_biometric_enroll_capture(dev, timeout, result);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define biometric_enroll_capture(dev, timeout, result) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BIOMETRIC_ENROLL_CAPTURE, biometric_enroll_capture, dev, timeout, result); syscall__retval = biometric_enroll_capture(dev, timeout, result); sys_port_trace_syscall_exit(K_SYSCALL_BIOMETRIC_ENROLL_CAPTURE, biometric_enroll_capture, dev, timeout, result, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_biometric_enroll_finalize(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int biometric_enroll_finalize(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_BIOMETRIC_ENROLL_FINALIZE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_biometric_enroll_finalize(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define biometric_enroll_finalize(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BIOMETRIC_ENROLL_FINALIZE, biometric_enroll_finalize, dev); syscall__retval = biometric_enroll_finalize(dev); sys_port_trace_syscall_exit(K_SYSCALL_BIOMETRIC_ENROLL_FINALIZE, biometric_enroll_finalize, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_biometric_enroll_abort(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int biometric_enroll_abort(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_BIOMETRIC_ENROLL_ABORT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_biometric_enroll_abort(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define biometric_enroll_abort(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BIOMETRIC_ENROLL_ABORT, biometric_enroll_abort, dev); syscall__retval = biometric_enroll_abort(dev); sys_port_trace_syscall_exit(K_SYSCALL_BIOMETRIC_ENROLL_ABORT, biometric_enroll_abort, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_biometric_template_store(const struct device * dev, uint16_t id, const uint8_t * data, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int biometric_template_store(const struct device * dev, uint16_t id, const uint8_t * data, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint16_t val; } parm1 = { .val = id };
|
||||
union { uintptr_t x; const uint8_t * val; } parm2 = { .val = data };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = size };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_BIOMETRIC_TEMPLATE_STORE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_biometric_template_store(dev, id, data, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define biometric_template_store(dev, id, data, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BIOMETRIC_TEMPLATE_STORE, biometric_template_store, dev, id, data, size); syscall__retval = biometric_template_store(dev, id, data, size); sys_port_trace_syscall_exit(K_SYSCALL_BIOMETRIC_TEMPLATE_STORE, biometric_template_store, dev, id, data, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_biometric_template_read(const struct device * dev, uint16_t id, uint8_t * data, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int biometric_template_read(const struct device * dev, uint16_t id, uint8_t * data, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint16_t val; } parm1 = { .val = id };
|
||||
union { uintptr_t x; uint8_t * val; } parm2 = { .val = data };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = size };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_BIOMETRIC_TEMPLATE_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_biometric_template_read(dev, id, data, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define biometric_template_read(dev, id, data, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BIOMETRIC_TEMPLATE_READ, biometric_template_read, dev, id, data, size); syscall__retval = biometric_template_read(dev, id, data, size); sys_port_trace_syscall_exit(K_SYSCALL_BIOMETRIC_TEMPLATE_READ, biometric_template_read, dev, id, data, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_biometric_template_delete(const struct device * dev, uint16_t id);
|
||||
|
||||
__pinned_func
|
||||
static inline int biometric_template_delete(const struct device * dev, uint16_t id)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint16_t val; } parm1 = { .val = id };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_BIOMETRIC_TEMPLATE_DELETE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_biometric_template_delete(dev, id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define biometric_template_delete(dev, id) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BIOMETRIC_TEMPLATE_DELETE, biometric_template_delete, dev, id); syscall__retval = biometric_template_delete(dev, id); sys_port_trace_syscall_exit(K_SYSCALL_BIOMETRIC_TEMPLATE_DELETE, biometric_template_delete, dev, id, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_biometric_template_delete_all(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int biometric_template_delete_all(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_BIOMETRIC_TEMPLATE_DELETE_ALL);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_biometric_template_delete_all(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define biometric_template_delete_all(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BIOMETRIC_TEMPLATE_DELETE_ALL, biometric_template_delete_all, dev); syscall__retval = biometric_template_delete_all(dev); sys_port_trace_syscall_exit(K_SYSCALL_BIOMETRIC_TEMPLATE_DELETE_ALL, biometric_template_delete_all, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_biometric_template_list(const struct device * dev, uint16_t * ids, size_t max_count, size_t * actual_count);
|
||||
|
||||
__pinned_func
|
||||
static inline int biometric_template_list(const struct device * dev, uint16_t * ids, size_t max_count, size_t * actual_count)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint16_t * val; } parm1 = { .val = ids };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = max_count };
|
||||
union { uintptr_t x; size_t * val; } parm3 = { .val = actual_count };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_BIOMETRIC_TEMPLATE_LIST);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_biometric_template_list(dev, ids, max_count, actual_count);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define biometric_template_list(dev, ids, max_count, actual_count) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BIOMETRIC_TEMPLATE_LIST, biometric_template_list, dev, ids, max_count, actual_count); syscall__retval = biometric_template_list(dev, ids, max_count, actual_count); sys_port_trace_syscall_exit(K_SYSCALL_BIOMETRIC_TEMPLATE_LIST, biometric_template_list, dev, ids, max_count, actual_count, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_biometric_match(const struct device * dev, enum biometric_match_mode mode, uint16_t template_id, k_timeout_t timeout, struct biometric_match_result * result);
|
||||
|
||||
__pinned_func
|
||||
static inline int biometric_match(const struct device * dev, enum biometric_match_mode mode, uint16_t template_id, k_timeout_t timeout, struct biometric_match_result * result)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum biometric_match_mode val; } parm1 = { .val = mode };
|
||||
union { uintptr_t x; uint16_t val; } parm2 = { .val = template_id };
|
||||
union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm3 = { .val = timeout };
|
||||
union { uintptr_t x; struct biometric_match_result * val; } parm4 = { .val = result };
|
||||
return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.split.lo, parm3.split.hi, parm4.x, K_SYSCALL_BIOMETRIC_MATCH);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_biometric_match(dev, mode, template_id, timeout, result);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define biometric_match(dev, mode, template_id, timeout, result) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BIOMETRIC_MATCH, biometric_match, dev, mode, template_id, timeout, result); syscall__retval = biometric_match(dev, mode, template_id, timeout, result); sys_port_trace_syscall_exit(K_SYSCALL_BIOMETRIC_MATCH, biometric_match, dev, mode, template_id, timeout, result, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_biometric_led_control(const struct device * dev, enum biometric_led_state state);
|
||||
|
||||
__pinned_func
|
||||
static inline int biometric_led_control(const struct device * dev, enum biometric_led_state state)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum biometric_led_state val; } parm1 = { .val = state };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_BIOMETRIC_LED_CONTROL);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_biometric_led_control(dev, state);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define biometric_led_control(dev, state) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BIOMETRIC_LED_CONTROL, biometric_led_control, dev, state); syscall__retval = biometric_led_control(dev, state); sys_port_trace_syscall_exit(K_SYSCALL_BIOMETRIC_LED_CONTROL, biometric_led_control, dev, state, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
100
build/zephyr/include/generated/zephyr/syscalls/cache.h
Normal file
100
build/zephyr/include/generated/zephyr/syscalls/cache.h
Normal file
@@ -0,0 +1,100 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_CACHE_H
|
||||
#define Z_INCLUDE_SYSCALLS_CACHE_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_sys_cache_data_flush_range(void * addr, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int sys_cache_data_flush_range(void * addr, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; void * val; } parm0 = { .val = addr };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = size };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sys_cache_data_flush_range(addr, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sys_cache_data_flush_range(addr, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE, sys_cache_data_flush_range, addr, size); syscall__retval = sys_cache_data_flush_range(addr, size); sys_port_trace_syscall_exit(K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE, sys_cache_data_flush_range, addr, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sys_cache_data_invd_range(void * addr, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int sys_cache_data_invd_range(void * addr, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; void * val; } parm0 = { .val = addr };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = size };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sys_cache_data_invd_range(addr, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sys_cache_data_invd_range(addr, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE, sys_cache_data_invd_range, addr, size); syscall__retval = sys_cache_data_invd_range(addr, size); sys_port_trace_syscall_exit(K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE, sys_cache_data_invd_range, addr, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sys_cache_data_flush_and_invd_range(void * addr, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int sys_cache_data_flush_and_invd_range(void * addr, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; void * val; } parm0 = { .val = addr };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = size };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sys_cache_data_flush_and_invd_range(addr, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sys_cache_data_flush_and_invd_range(addr, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE, sys_cache_data_flush_and_invd_range, addr, size); syscall__retval = sys_cache_data_flush_and_invd_range(addr, size); sys_port_trace_syscall_exit(K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE, sys_cache_data_flush_and_invd_range, addr, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
812
build/zephyr/include/generated/zephyr/syscalls/can.h
Normal file
812
build/zephyr/include/generated/zephyr/syscalls/can.h
Normal file
@@ -0,0 +1,812 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_CAN_H
|
||||
#define Z_INCLUDE_SYSCALLS_CAN_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_can_get_core_clock(const struct device * dev, uint32_t * rate);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_get_core_clock(const struct device * dev, uint32_t * rate)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t * val; } parm1 = { .val = rate };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_GET_CORE_CLOCK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_core_clock(dev, rate);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_core_clock(dev, rate) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_CORE_CLOCK, can_get_core_clock, dev, rate); syscall__retval = can_get_core_clock(dev, rate); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_CORE_CLOCK, can_get_core_clock, dev, rate, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_get_bitrate_min(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_get_bitrate_min(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_BITRATE_MIN);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_bitrate_min(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_bitrate_min(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_BITRATE_MIN, can_get_bitrate_min, dev); syscall__retval = can_get_bitrate_min(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_BITRATE_MIN, can_get_bitrate_min, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_get_bitrate_max(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_get_bitrate_max(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_BITRATE_MAX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_bitrate_max(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_bitrate_max(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_BITRATE_MAX, can_get_bitrate_max, dev); syscall__retval = can_get_bitrate_max(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_BITRATE_MAX, can_get_bitrate_max, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern const struct can_timing * z_impl_can_get_timing_min(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct can_timing * can_get_timing_min(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (const struct can_timing *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TIMING_MIN);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_timing_min(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_timing_min(dev) ({ const struct can_timing * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TIMING_MIN, can_get_timing_min, dev); syscall__retval = can_get_timing_min(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TIMING_MIN, can_get_timing_min, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern const struct can_timing * z_impl_can_get_timing_max(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct can_timing * can_get_timing_max(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (const struct can_timing *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TIMING_MAX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_timing_max(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_timing_max(dev) ({ const struct can_timing * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TIMING_MAX, can_get_timing_max, dev); syscall__retval = can_get_timing_max(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TIMING_MAX, can_get_timing_max, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_calc_timing(const struct device * dev, struct can_timing * res, uint32_t bitrate, uint16_t sample_pnt);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_calc_timing(const struct device * dev, struct can_timing * res, uint32_t bitrate, uint16_t sample_pnt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct can_timing * val; } parm1 = { .val = res };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = bitrate };
|
||||
union { uintptr_t x; uint16_t val; } parm3 = { .val = sample_pnt };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_CAN_CALC_TIMING);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_calc_timing(dev, res, bitrate, sample_pnt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_calc_timing(dev, res, bitrate, sample_pnt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_CALC_TIMING, can_calc_timing, dev, res, bitrate, sample_pnt); syscall__retval = can_calc_timing(dev, res, bitrate, sample_pnt); sys_port_trace_syscall_exit(K_SYSCALL_CAN_CALC_TIMING, can_calc_timing, dev, res, bitrate, sample_pnt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern const struct can_timing * z_impl_can_get_timing_data_min(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct can_timing * can_get_timing_data_min(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (const struct can_timing *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TIMING_DATA_MIN);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_timing_data_min(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_timing_data_min(dev) ({ const struct can_timing * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TIMING_DATA_MIN, can_get_timing_data_min, dev); syscall__retval = can_get_timing_data_min(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TIMING_DATA_MIN, can_get_timing_data_min, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern const struct can_timing * z_impl_can_get_timing_data_max(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct can_timing * can_get_timing_data_max(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (const struct can_timing *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TIMING_DATA_MAX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_timing_data_max(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_timing_data_max(dev) ({ const struct can_timing * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TIMING_DATA_MAX, can_get_timing_data_max, dev); syscall__retval = can_get_timing_data_max(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TIMING_DATA_MAX, can_get_timing_data_max, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_calc_timing_data(const struct device * dev, struct can_timing * res, uint32_t bitrate, uint16_t sample_pnt);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_calc_timing_data(const struct device * dev, struct can_timing * res, uint32_t bitrate, uint16_t sample_pnt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct can_timing * val; } parm1 = { .val = res };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = bitrate };
|
||||
union { uintptr_t x; uint16_t val; } parm3 = { .val = sample_pnt };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_CAN_CALC_TIMING_DATA);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_calc_timing_data(dev, res, bitrate, sample_pnt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_calc_timing_data(dev, res, bitrate, sample_pnt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_CALC_TIMING_DATA, can_calc_timing_data, dev, res, bitrate, sample_pnt); syscall__retval = can_calc_timing_data(dev, res, bitrate, sample_pnt); sys_port_trace_syscall_exit(K_SYSCALL_CAN_CALC_TIMING_DATA, can_calc_timing_data, dev, res, bitrate, sample_pnt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_set_timing_data(const struct device * dev, const struct can_timing * timing_data);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_set_timing_data(const struct device * dev, const struct can_timing * timing_data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct can_timing * val; } parm1 = { .val = timing_data };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_TIMING_DATA);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_set_timing_data(dev, timing_data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_set_timing_data(dev, timing_data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_TIMING_DATA, can_set_timing_data, dev, timing_data); syscall__retval = can_set_timing_data(dev, timing_data); sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_TIMING_DATA, can_set_timing_data, dev, timing_data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_set_bitrate_data(const struct device * dev, uint32_t bitrate_data);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_set_bitrate_data(const struct device * dev, uint32_t bitrate_data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = bitrate_data };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_BITRATE_DATA);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_set_bitrate_data(dev, bitrate_data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_set_bitrate_data(dev, bitrate_data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_BITRATE_DATA, can_set_bitrate_data, dev, bitrate_data); syscall__retval = can_set_bitrate_data(dev, bitrate_data); sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_BITRATE_DATA, can_set_bitrate_data, dev, bitrate_data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_set_timing(const struct device * dev, const struct can_timing * timing);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_set_timing(const struct device * dev, const struct can_timing * timing)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct can_timing * val; } parm1 = { .val = timing };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_TIMING);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_set_timing(dev, timing);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_set_timing(dev, timing) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_TIMING, can_set_timing, dev, timing); syscall__retval = can_set_timing(dev, timing); sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_TIMING, can_set_timing, dev, timing, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_get_capabilities(const struct device * dev, can_mode_t * cap);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_get_capabilities(const struct device * dev, can_mode_t * cap)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; can_mode_t * val; } parm1 = { .val = cap };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_GET_CAPABILITIES);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_capabilities(dev, cap);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_capabilities(dev, cap) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_CAPABILITIES, can_get_capabilities, dev, cap); syscall__retval = can_get_capabilities(dev, cap); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_CAPABILITIES, can_get_capabilities, dev, cap, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern const struct device * z_impl_can_get_transceiver(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct device * can_get_transceiver(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (const struct device *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TRANSCEIVER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_transceiver(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_transceiver(dev) ({ const struct device * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TRANSCEIVER, can_get_transceiver, dev); syscall__retval = can_get_transceiver(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TRANSCEIVER, can_get_transceiver, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_start(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_start(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_START);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_start(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_start(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_START, can_start, dev); syscall__retval = can_start(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_START, can_start, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_stop(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_stop(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STOP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stop(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stop(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STOP, can_stop, dev); syscall__retval = can_stop(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STOP, can_stop, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_set_mode(const struct device * dev, can_mode_t mode);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_set_mode(const struct device * dev, can_mode_t mode)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; can_mode_t val; } parm1 = { .val = mode };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_MODE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_set_mode(dev, mode);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_set_mode(dev, mode) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_MODE, can_set_mode, dev, mode); syscall__retval = can_set_mode(dev, mode); sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_MODE, can_set_mode, dev, mode, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern can_mode_t z_impl_can_get_mode(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline can_mode_t can_get_mode(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (can_mode_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_MODE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_mode(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_mode(dev) ({ can_mode_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_MODE, can_get_mode, dev); syscall__retval = can_get_mode(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_MODE, can_get_mode, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_set_bitrate(const struct device * dev, uint32_t bitrate);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_set_bitrate(const struct device * dev, uint32_t bitrate)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = bitrate };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_BITRATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_set_bitrate(dev, bitrate);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_set_bitrate(dev, bitrate) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_BITRATE, can_set_bitrate, dev, bitrate); syscall__retval = can_set_bitrate(dev, bitrate); sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_BITRATE, can_set_bitrate, dev, bitrate, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_send(const struct device * dev, const struct can_frame * frame, k_timeout_t timeout, can_tx_callback_t callback, void * user_data);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_send(const struct device * dev, const struct can_frame * frame, k_timeout_t timeout, can_tx_callback_t callback, void * user_data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct can_frame * val; } parm1 = { .val = frame };
|
||||
union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm2 = { .val = timeout };
|
||||
union { uintptr_t x; can_tx_callback_t val; } parm3 = { .val = callback };
|
||||
union { uintptr_t x; void * val; } parm4 = { .val = user_data };
|
||||
return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.split.lo, parm2.split.hi, parm3.x, parm4.x, K_SYSCALL_CAN_SEND);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_send(dev, frame, timeout, callback, user_data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_send(dev, frame, timeout, callback, user_data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_SEND, can_send, dev, frame, timeout, callback, user_data); syscall__retval = can_send(dev, frame, timeout, callback, user_data); sys_port_trace_syscall_exit(K_SYSCALL_CAN_SEND, can_send, dev, frame, timeout, callback, user_data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_add_rx_filter_msgq(const struct device * dev, struct k_msgq * msgq, const struct can_filter * filter);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_add_rx_filter_msgq(const struct device * dev, struct k_msgq * msgq, const struct can_filter * filter)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct k_msgq * val; } parm1 = { .val = msgq };
|
||||
union { uintptr_t x; const struct can_filter * val; } parm2 = { .val = filter };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_add_rx_filter_msgq(dev, msgq, filter);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_add_rx_filter_msgq(dev, msgq, filter) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ, can_add_rx_filter_msgq, dev, msgq, filter); syscall__retval = can_add_rx_filter_msgq(dev, msgq, filter); sys_port_trace_syscall_exit(K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ, can_add_rx_filter_msgq, dev, msgq, filter, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_can_remove_rx_filter(const struct device * dev, int filter_id);
|
||||
|
||||
__pinned_func
|
||||
static inline void can_remove_rx_filter(const struct device * dev, int filter_id)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; int val; } parm1 = { .val = filter_id };
|
||||
(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_REMOVE_RX_FILTER);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_can_remove_rx_filter(dev, filter_id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_remove_rx_filter(dev, filter_id) do { sys_port_trace_syscall_enter(K_SYSCALL_CAN_REMOVE_RX_FILTER, can_remove_rx_filter, dev, filter_id); can_remove_rx_filter(dev, filter_id); sys_port_trace_syscall_exit(K_SYSCALL_CAN_REMOVE_RX_FILTER, can_remove_rx_filter, dev, filter_id); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_get_max_filters(const struct device * dev, bool ide);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_get_max_filters(const struct device * dev, bool ide)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; bool val; } parm1 = { .val = ide };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_GET_MAX_FILTERS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_max_filters(dev, ide);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_max_filters(dev, ide) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_MAX_FILTERS, can_get_max_filters, dev, ide); syscall__retval = can_get_max_filters(dev, ide); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_MAX_FILTERS, can_get_max_filters, dev, ide, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_get_state(const struct device * dev, enum can_state * state, struct can_bus_err_cnt * err_cnt);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_get_state(const struct device * dev, enum can_state * state, struct can_bus_err_cnt * err_cnt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum can_state * val; } parm1 = { .val = state };
|
||||
union { uintptr_t x; struct can_bus_err_cnt * val; } parm2 = { .val = err_cnt };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_CAN_GET_STATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_state(dev, state, err_cnt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_state(dev, state, err_cnt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_STATE, can_get_state, dev, state, err_cnt); syscall__retval = can_get_state(dev, state, err_cnt); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_STATE, can_get_state, dev, state, err_cnt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_recover(const struct device * dev, k_timeout_t timeout);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_recover(const struct device * dev, k_timeout_t timeout)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm1 = { .val = timeout };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.split.lo, parm1.split.hi, K_SYSCALL_CAN_RECOVER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_recover(dev, timeout);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_recover(dev, timeout) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_RECOVER, can_recover, dev, timeout); syscall__retval = can_recover(dev, timeout); sys_port_trace_syscall_exit(K_SYSCALL_CAN_RECOVER, can_recover, dev, timeout, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_bit_errors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_bit_errors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_BIT_ERRORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_bit_errors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_bit_errors(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_BIT_ERRORS, can_stats_get_bit_errors, dev); syscall__retval = can_stats_get_bit_errors(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_BIT_ERRORS, can_stats_get_bit_errors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_bit0_errors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_bit0_errors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_bit0_errors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_bit0_errors(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS, can_stats_get_bit0_errors, dev); syscall__retval = can_stats_get_bit0_errors(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS, can_stats_get_bit0_errors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_bit1_errors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_bit1_errors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_bit1_errors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_bit1_errors(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS, can_stats_get_bit1_errors, dev); syscall__retval = can_stats_get_bit1_errors(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS, can_stats_get_bit1_errors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_stuff_errors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_stuff_errors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_stuff_errors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_stuff_errors(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS, can_stats_get_stuff_errors, dev); syscall__retval = can_stats_get_stuff_errors(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS, can_stats_get_stuff_errors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_crc_errors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_crc_errors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_CRC_ERRORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_crc_errors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_crc_errors(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_CRC_ERRORS, can_stats_get_crc_errors, dev); syscall__retval = can_stats_get_crc_errors(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_CRC_ERRORS, can_stats_get_crc_errors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_form_errors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_form_errors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_FORM_ERRORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_form_errors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_form_errors(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_FORM_ERRORS, can_stats_get_form_errors, dev); syscall__retval = can_stats_get_form_errors(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_FORM_ERRORS, can_stats_get_form_errors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_ack_errors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_ack_errors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_ACK_ERRORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_ack_errors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_ack_errors(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_ACK_ERRORS, can_stats_get_ack_errors, dev); syscall__retval = can_stats_get_ack_errors(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_ACK_ERRORS, can_stats_get_ack_errors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_rx_overruns(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_rx_overruns(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_rx_overruns(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_rx_overruns(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS, can_stats_get_rx_overruns, dev); syscall__retval = can_stats_get_rx_overruns(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS, can_stats_get_rx_overruns, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
102
build/zephyr/include/generated/zephyr/syscalls/charger.h
Normal file
102
build/zephyr/include/generated/zephyr/syscalls/charger.h
Normal file
@@ -0,0 +1,102 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_CHARGER_H
|
||||
#define Z_INCLUDE_SYSCALLS_CHARGER_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_charger_get_prop(const struct device * dev, const charger_prop_t prop, union charger_propval * val);
|
||||
|
||||
__pinned_func
|
||||
static inline int charger_get_prop(const struct device * dev, const charger_prop_t prop, union charger_propval * val)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const charger_prop_t val; } parm1 = { .val = prop };
|
||||
union { uintptr_t x; union charger_propval * val; } parm2 = { .val = val };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_CHARGER_GET_PROP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_charger_get_prop(dev, prop, val);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define charger_get_prop(dev, prop, val) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CHARGER_GET_PROP, charger_get_prop, dev, prop, val); syscall__retval = charger_get_prop(dev, prop, val); sys_port_trace_syscall_exit(K_SYSCALL_CHARGER_GET_PROP, charger_get_prop, dev, prop, val, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_charger_set_prop(const struct device * dev, const charger_prop_t prop, const union charger_propval * val);
|
||||
|
||||
__pinned_func
|
||||
static inline int charger_set_prop(const struct device * dev, const charger_prop_t prop, const union charger_propval * val)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const charger_prop_t val; } parm1 = { .val = prop };
|
||||
union { uintptr_t x; const union charger_propval * val; } parm2 = { .val = val };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_CHARGER_SET_PROP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_charger_set_prop(dev, prop, val);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define charger_set_prop(dev, prop, val) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CHARGER_SET_PROP, charger_set_prop, dev, prop, val); syscall__retval = charger_set_prop(dev, prop, val); sys_port_trace_syscall_exit(K_SYSCALL_CHARGER_SET_PROP, charger_set_prop, dev, prop, val, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_charger_charge_enable(const struct device * dev, const bool enable);
|
||||
|
||||
__pinned_func
|
||||
static inline int charger_charge_enable(const struct device * dev, const bool enable)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const bool val; } parm1 = { .val = enable };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CHARGER_CHARGE_ENABLE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_charger_charge_enable(dev, enable);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define charger_charge_enable(dev, enable) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CHARGER_CHARGE_ENABLE, charger_charge_enable, dev, enable); syscall__retval = charger_charge_enable(dev, enable); sys_port_trace_syscall_exit(K_SYSCALL_CHARGER_CHARGE_ENABLE, charger_charge_enable, dev, enable, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
102
build/zephyr/include/generated/zephyr/syscalls/clock.h
Normal file
102
build/zephyr/include/generated/zephyr/syscalls/clock.h
Normal file
@@ -0,0 +1,102 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_CLOCK_H
|
||||
#define Z_INCLUDE_SYSCALLS_CLOCK_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_sys_clock_getrtoffset(struct timespec * tp);
|
||||
|
||||
__pinned_func
|
||||
static inline void sys_clock_getrtoffset(struct timespec * tp)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct timespec * val; } parm0 = { .val = tp };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_SYS_CLOCK_GETRTOFFSET);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_sys_clock_getrtoffset(tp);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sys_clock_getrtoffset(tp) do { sys_port_trace_syscall_enter(K_SYSCALL_SYS_CLOCK_GETRTOFFSET, sys_clock_getrtoffset, tp); sys_clock_getrtoffset(tp); sys_port_trace_syscall_exit(K_SYSCALL_SYS_CLOCK_GETRTOFFSET, sys_clock_getrtoffset, tp); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sys_clock_settime(int clock_id, const struct timespec * tp);
|
||||
|
||||
__pinned_func
|
||||
static inline int sys_clock_settime(int clock_id, const struct timespec * tp)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = clock_id };
|
||||
union { uintptr_t x; const struct timespec * val; } parm1 = { .val = tp };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_CLOCK_SETTIME);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sys_clock_settime(clock_id, tp);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sys_clock_settime(clock_id, tp) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SYS_CLOCK_SETTIME, sys_clock_settime, clock_id, tp); syscall__retval = sys_clock_settime(clock_id, tp); sys_port_trace_syscall_exit(K_SYSCALL_SYS_CLOCK_SETTIME, sys_clock_settime, clock_id, tp, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sys_clock_nanosleep(int clock_id, int flags, const struct timespec * rqtp, struct timespec * rmtp);
|
||||
|
||||
__pinned_func
|
||||
static inline int sys_clock_nanosleep(int clock_id, int flags, const struct timespec * rqtp, struct timespec * rmtp)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = clock_id };
|
||||
union { uintptr_t x; int val; } parm1 = { .val = flags };
|
||||
union { uintptr_t x; const struct timespec * val; } parm2 = { .val = rqtp };
|
||||
union { uintptr_t x; struct timespec * val; } parm3 = { .val = rmtp };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_SYS_CLOCK_NANOSLEEP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sys_clock_nanosleep(clock_id, flags, rqtp, rmtp);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sys_clock_nanosleep(clock_id, flags, rqtp, rmtp) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SYS_CLOCK_NANOSLEEP, sys_clock_nanosleep, clock_id, flags, rqtp, rmtp); syscall__retval = sys_clock_nanosleep(clock_id, flags, rqtp, rmtp); sys_port_trace_syscall_exit(K_SYSCALL_SYS_CLOCK_NANOSLEEP, sys_clock_nanosleep, clock_id, flags, rqtp, rmtp, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
98
build/zephyr/include/generated/zephyr/syscalls/comparator.h
Normal file
98
build/zephyr/include/generated/zephyr/syscalls/comparator.h
Normal file
@@ -0,0 +1,98 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_COMPARATOR_H
|
||||
#define Z_INCLUDE_SYSCALLS_COMPARATOR_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_comparator_get_output(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int comparator_get_output(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_COMPARATOR_GET_OUTPUT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_comparator_get_output(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define comparator_get_output(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COMPARATOR_GET_OUTPUT, comparator_get_output, dev); syscall__retval = comparator_get_output(dev); sys_port_trace_syscall_exit(K_SYSCALL_COMPARATOR_GET_OUTPUT, comparator_get_output, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_comparator_set_trigger(const struct device * dev, enum comparator_trigger trigger);
|
||||
|
||||
__pinned_func
|
||||
static inline int comparator_set_trigger(const struct device * dev, enum comparator_trigger trigger)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum comparator_trigger val; } parm1 = { .val = trigger };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COMPARATOR_SET_TRIGGER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_comparator_set_trigger(dev, trigger);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define comparator_set_trigger(dev, trigger) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COMPARATOR_SET_TRIGGER, comparator_set_trigger, dev, trigger); syscall__retval = comparator_set_trigger(dev, trigger); sys_port_trace_syscall_exit(K_SYSCALL_COMPARATOR_SET_TRIGGER, comparator_set_trigger, dev, trigger, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_comparator_trigger_is_pending(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int comparator_trigger_is_pending(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_COMPARATOR_TRIGGER_IS_PENDING);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_comparator_trigger_is_pending(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define comparator_trigger_is_pending(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COMPARATOR_TRIGGER_IS_PENDING, comparator_trigger_is_pending, dev); syscall__retval = comparator_trigger_is_pending(dev); sys_port_trace_syscall_exit(K_SYSCALL_COMPARATOR_TRIGGER_IS_PENDING, comparator_trigger_is_pending, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
832
build/zephyr/include/generated/zephyr/syscalls/counter.h
Normal file
832
build/zephyr/include/generated/zephyr/syscalls/counter.h
Normal file
@@ -0,0 +1,832 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_COUNTER_H
|
||||
#define Z_INCLUDE_SYSCALLS_COUNTER_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern bool z_impl_counter_is_counting_up(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline bool counter_is_counting_up(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (bool) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_IS_COUNTING_UP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_is_counting_up(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_is_counting_up(dev) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_IS_COUNTING_UP, counter_is_counting_up, dev); syscall__retval = counter_is_counting_up(dev); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_IS_COUNTING_UP, counter_is_counting_up, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint8_t z_impl_counter_get_num_of_channels(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint8_t counter_get_num_of_channels(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint8_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_GET_NUM_OF_CHANNELS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_num_of_channels(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_num_of_channels(dev) ({ uint8_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_NUM_OF_CHANNELS, counter_get_num_of_channels, dev); syscall__retval = counter_get_num_of_channels(dev); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_NUM_OF_CHANNELS, counter_get_num_of_channels, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_counter_get_frequency(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t counter_get_frequency(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_GET_FREQUENCY);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_frequency(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_frequency(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_FREQUENCY, counter_get_frequency, dev); syscall__retval = counter_get_frequency(dev); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_FREQUENCY, counter_get_frequency, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint64_t z_impl_counter_get_frequency_64(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint64_t counter_get_frequency_64(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
uint64_t ret64;
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
(void) arch_syscall_invoke2(parm0.x, (uintptr_t)&ret64, K_SYSCALL_COUNTER_GET_FREQUENCY_64);
|
||||
return (uint64_t) ret64;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_frequency_64(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_frequency_64(dev) ({ uint64_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_FREQUENCY_64, counter_get_frequency_64, dev); syscall__retval = counter_get_frequency_64(dev); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_FREQUENCY_64, counter_get_frequency_64, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_counter_us_to_ticks(const struct device * dev, uint64_t us);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t counter_us_to_ticks(const struct device * dev, uint64_t us)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { struct { uintptr_t lo, hi; } split; uint64_t val; } parm1 = { .val = us };
|
||||
return (uint32_t) arch_syscall_invoke3(parm0.x, parm1.split.lo, parm1.split.hi, K_SYSCALL_COUNTER_US_TO_TICKS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_us_to_ticks(dev, us);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_us_to_ticks(dev, us) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_US_TO_TICKS, counter_us_to_ticks, dev, us); syscall__retval = counter_us_to_ticks(dev, us); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_US_TO_TICKS, counter_us_to_ticks, dev, us, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint64_t z_impl_counter_us_to_ticks_64(const struct device * dev, uint64_t us);
|
||||
|
||||
__pinned_func
|
||||
static inline uint64_t counter_us_to_ticks_64(const struct device * dev, uint64_t us)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
uint64_t ret64;
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { struct { uintptr_t lo, hi; } split; uint64_t val; } parm1 = { .val = us };
|
||||
(void) arch_syscall_invoke4(parm0.x, parm1.split.lo, parm1.split.hi, (uintptr_t)&ret64, K_SYSCALL_COUNTER_US_TO_TICKS_64);
|
||||
return (uint64_t) ret64;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_us_to_ticks_64(dev, us);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_us_to_ticks_64(dev, us) ({ uint64_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_US_TO_TICKS_64, counter_us_to_ticks_64, dev, us); syscall__retval = counter_us_to_ticks_64(dev, us); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_US_TO_TICKS_64, counter_us_to_ticks_64, dev, us, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint64_t z_impl_counter_ticks_to_us(const struct device * dev, uint32_t ticks);
|
||||
|
||||
__pinned_func
|
||||
static inline uint64_t counter_ticks_to_us(const struct device * dev, uint32_t ticks)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
uint64_t ret64;
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = ticks };
|
||||
(void) arch_syscall_invoke3(parm0.x, parm1.x, (uintptr_t)&ret64, K_SYSCALL_COUNTER_TICKS_TO_US);
|
||||
return (uint64_t) ret64;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_ticks_to_us(dev, ticks);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_ticks_to_us(dev, ticks) ({ uint64_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_TICKS_TO_US, counter_ticks_to_us, dev, ticks); syscall__retval = counter_ticks_to_us(dev, ticks); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_TICKS_TO_US, counter_ticks_to_us, dev, ticks, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint64_t z_impl_counter_ticks_to_us_64(const struct device * dev, uint64_t ticks);
|
||||
|
||||
__pinned_func
|
||||
static inline uint64_t counter_ticks_to_us_64(const struct device * dev, uint64_t ticks)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
uint64_t ret64;
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { struct { uintptr_t lo, hi; } split; uint64_t val; } parm1 = { .val = ticks };
|
||||
(void) arch_syscall_invoke4(parm0.x, parm1.split.lo, parm1.split.hi, (uintptr_t)&ret64, K_SYSCALL_COUNTER_TICKS_TO_US_64);
|
||||
return (uint64_t) ret64;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_ticks_to_us_64(dev, ticks);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_ticks_to_us_64(dev, ticks) ({ uint64_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_TICKS_TO_US_64, counter_ticks_to_us_64, dev, ticks); syscall__retval = counter_ticks_to_us_64(dev, ticks); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_TICKS_TO_US_64, counter_ticks_to_us_64, dev, ticks, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_counter_ns_to_ticks(const struct device * dev, uint64_t ns);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t counter_ns_to_ticks(const struct device * dev, uint64_t ns)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { struct { uintptr_t lo, hi; } split; uint64_t val; } parm1 = { .val = ns };
|
||||
return (uint32_t) arch_syscall_invoke3(parm0.x, parm1.split.lo, parm1.split.hi, K_SYSCALL_COUNTER_NS_TO_TICKS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_ns_to_ticks(dev, ns);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_ns_to_ticks(dev, ns) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_NS_TO_TICKS, counter_ns_to_ticks, dev, ns); syscall__retval = counter_ns_to_ticks(dev, ns); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_NS_TO_TICKS, counter_ns_to_ticks, dev, ns, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint64_t z_impl_counter_ns_to_ticks_64(const struct device * dev, uint64_t ns);
|
||||
|
||||
__pinned_func
|
||||
static inline uint64_t counter_ns_to_ticks_64(const struct device * dev, uint64_t ns)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
uint64_t ret64;
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { struct { uintptr_t lo, hi; } split; uint64_t val; } parm1 = { .val = ns };
|
||||
(void) arch_syscall_invoke4(parm0.x, parm1.split.lo, parm1.split.hi, (uintptr_t)&ret64, K_SYSCALL_COUNTER_NS_TO_TICKS_64);
|
||||
return (uint64_t) ret64;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_ns_to_ticks_64(dev, ns);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_ns_to_ticks_64(dev, ns) ({ uint64_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_NS_TO_TICKS_64, counter_ns_to_ticks_64, dev, ns); syscall__retval = counter_ns_to_ticks_64(dev, ns); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_NS_TO_TICKS_64, counter_ns_to_ticks_64, dev, ns, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint64_t z_impl_counter_ticks_to_ns(const struct device * dev, uint32_t ticks);
|
||||
|
||||
__pinned_func
|
||||
static inline uint64_t counter_ticks_to_ns(const struct device * dev, uint32_t ticks)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
uint64_t ret64;
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = ticks };
|
||||
(void) arch_syscall_invoke3(parm0.x, parm1.x, (uintptr_t)&ret64, K_SYSCALL_COUNTER_TICKS_TO_NS);
|
||||
return (uint64_t) ret64;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_ticks_to_ns(dev, ticks);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_ticks_to_ns(dev, ticks) ({ uint64_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_TICKS_TO_NS, counter_ticks_to_ns, dev, ticks); syscall__retval = counter_ticks_to_ns(dev, ticks); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_TICKS_TO_NS, counter_ticks_to_ns, dev, ticks, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint64_t z_impl_counter_ticks_to_ns_64(const struct device * dev, uint64_t ticks);
|
||||
|
||||
__pinned_func
|
||||
static inline uint64_t counter_ticks_to_ns_64(const struct device * dev, uint64_t ticks)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
uint64_t ret64;
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { struct { uintptr_t lo, hi; } split; uint64_t val; } parm1 = { .val = ticks };
|
||||
(void) arch_syscall_invoke4(parm0.x, parm1.split.lo, parm1.split.hi, (uintptr_t)&ret64, K_SYSCALL_COUNTER_TICKS_TO_NS_64);
|
||||
return (uint64_t) ret64;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_ticks_to_ns_64(dev, ticks);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_ticks_to_ns_64(dev, ticks) ({ uint64_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_TICKS_TO_NS_64, counter_ticks_to_ns_64, dev, ticks); syscall__retval = counter_ticks_to_ns_64(dev, ticks); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_TICKS_TO_NS_64, counter_ticks_to_ns_64, dev, ticks, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_counter_get_max_top_value(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t counter_get_max_top_value(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_max_top_value(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_max_top_value(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE, counter_get_max_top_value, dev); syscall__retval = counter_get_max_top_value(dev); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE, counter_get_max_top_value, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_start(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_start(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_START);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_start(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_start(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_START, counter_start, dev); syscall__retval = counter_start(dev); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_START, counter_start, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_stop(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_stop(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_STOP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_stop(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_stop(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_STOP, counter_stop, dev); syscall__retval = counter_stop(dev); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_STOP, counter_stop, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_get_value(const struct device * dev, uint32_t * ticks);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_get_value(const struct device * dev, uint32_t * ticks)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t * val; } parm1 = { .val = ticks };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_GET_VALUE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_value(dev, ticks);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_value(dev, ticks) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_VALUE, counter_get_value, dev, ticks); syscall__retval = counter_get_value(dev, ticks); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_VALUE, counter_get_value, dev, ticks, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_reset(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_reset(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_RESET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_reset(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_reset(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_RESET, counter_reset, dev); syscall__retval = counter_reset(dev); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_RESET, counter_reset, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_set_value(const struct device * dev, uint32_t ticks);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_set_value(const struct device * dev, uint32_t ticks)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = ticks };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_SET_VALUE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_set_value(dev, ticks);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_set_value(dev, ticks) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_SET_VALUE, counter_set_value, dev, ticks); syscall__retval = counter_set_value(dev, ticks); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_SET_VALUE, counter_set_value, dev, ticks, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_set_channel_alarm(const struct device * dev, uint8_t chan_id, const struct counter_alarm_cfg * alarm_cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_set_channel_alarm(const struct device * dev, uint8_t chan_id, const struct counter_alarm_cfg * alarm_cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = chan_id };
|
||||
union { uintptr_t x; const struct counter_alarm_cfg * val; } parm2 = { .val = alarm_cfg };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_COUNTER_SET_CHANNEL_ALARM);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_set_channel_alarm(dev, chan_id, alarm_cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_set_channel_alarm(dev, chan_id, alarm_cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_SET_CHANNEL_ALARM, counter_set_channel_alarm, dev, chan_id, alarm_cfg); syscall__retval = counter_set_channel_alarm(dev, chan_id, alarm_cfg); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_SET_CHANNEL_ALARM, counter_set_channel_alarm, dev, chan_id, alarm_cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_cancel_channel_alarm(const struct device * dev, uint8_t chan_id);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_cancel_channel_alarm(const struct device * dev, uint8_t chan_id)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = chan_id };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_cancel_channel_alarm(dev, chan_id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_cancel_channel_alarm(dev, chan_id) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM, counter_cancel_channel_alarm, dev, chan_id); syscall__retval = counter_cancel_channel_alarm(dev, chan_id); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM, counter_cancel_channel_alarm, dev, chan_id, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_set_top_value(const struct device * dev, const struct counter_top_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_set_top_value(const struct device * dev, const struct counter_top_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct counter_top_cfg * val; } parm1 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_SET_TOP_VALUE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_set_top_value(dev, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_set_top_value(dev, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_SET_TOP_VALUE, counter_set_top_value, dev, cfg); syscall__retval = counter_set_top_value(dev, cfg); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_SET_TOP_VALUE, counter_set_top_value, dev, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_get_pending_int(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_get_pending_int(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_GET_PENDING_INT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_pending_int(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_pending_int(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_PENDING_INT, counter_get_pending_int, dev); syscall__retval = counter_get_pending_int(dev); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_PENDING_INT, counter_get_pending_int, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_counter_get_top_value(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t counter_get_top_value(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_GET_TOP_VALUE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_top_value(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_top_value(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_TOP_VALUE, counter_get_top_value, dev); syscall__retval = counter_get_top_value(dev); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_TOP_VALUE, counter_get_top_value, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_set_guard_period(const struct device * dev, uint32_t ticks, uint32_t flags);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_set_guard_period(const struct device * dev, uint32_t ticks, uint32_t flags)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = ticks };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = flags };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_COUNTER_SET_GUARD_PERIOD);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_set_guard_period(dev, ticks, flags);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_set_guard_period(dev, ticks, flags) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_SET_GUARD_PERIOD, counter_set_guard_period, dev, ticks, flags); syscall__retval = counter_set_guard_period(dev, ticks, flags); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_SET_GUARD_PERIOD, counter_set_guard_period, dev, ticks, flags, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_counter_get_guard_period(const struct device * dev, uint32_t flags);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t counter_get_guard_period(const struct device * dev, uint32_t flags)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = flags };
|
||||
return (uint32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_GET_GUARD_PERIOD);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_guard_period(dev, flags);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_guard_period(dev, flags) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_GUARD_PERIOD, counter_get_guard_period, dev, flags); syscall__retval = counter_get_guard_period(dev, flags); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_GUARD_PERIOD, counter_get_guard_period, dev, flags, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint64_t z_impl_counter_get_max_top_value_64(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint64_t counter_get_max_top_value_64(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
uint64_t ret64;
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
(void) arch_syscall_invoke2(parm0.x, (uintptr_t)&ret64, K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE_64);
|
||||
return (uint64_t) ret64;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_max_top_value_64(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_max_top_value_64(dev) ({ uint64_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE_64, counter_get_max_top_value_64, dev); syscall__retval = counter_get_max_top_value_64(dev); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE_64, counter_get_max_top_value_64, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_set_top_value_64(const struct device * dev, const struct counter_top_cfg_64 * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_set_top_value_64(const struct device * dev, const struct counter_top_cfg_64 * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct counter_top_cfg_64 * val; } parm1 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_SET_TOP_VALUE_64);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_set_top_value_64(dev, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_set_top_value_64(dev, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_SET_TOP_VALUE_64, counter_set_top_value_64, dev, cfg); syscall__retval = counter_set_top_value_64(dev, cfg); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_SET_TOP_VALUE_64, counter_set_top_value_64, dev, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_set_channel_alarm_64(const struct device * dev, uint8_t chan_id, const struct counter_alarm_cfg_64 * alarm_cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_set_channel_alarm_64(const struct device * dev, uint8_t chan_id, const struct counter_alarm_cfg_64 * alarm_cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = chan_id };
|
||||
union { uintptr_t x; const struct counter_alarm_cfg_64 * val; } parm2 = { .val = alarm_cfg };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_COUNTER_SET_CHANNEL_ALARM_64);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_set_channel_alarm_64(dev, chan_id, alarm_cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_set_channel_alarm_64(dev, chan_id, alarm_cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_SET_CHANNEL_ALARM_64, counter_set_channel_alarm_64, dev, chan_id, alarm_cfg); syscall__retval = counter_set_channel_alarm_64(dev, chan_id, alarm_cfg); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_SET_CHANNEL_ALARM_64, counter_set_channel_alarm_64, dev, chan_id, alarm_cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint64_t z_impl_counter_get_top_value_64(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint64_t counter_get_top_value_64(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
uint64_t ret64;
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
(void) arch_syscall_invoke2(parm0.x, (uintptr_t)&ret64, K_SYSCALL_COUNTER_GET_TOP_VALUE_64);
|
||||
return (uint64_t) ret64;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_top_value_64(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_top_value_64(dev) ({ uint64_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_TOP_VALUE_64, counter_get_top_value_64, dev); syscall__retval = counter_get_top_value_64(dev); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_TOP_VALUE_64, counter_get_top_value_64, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_set_guard_period_64(const struct device * dev, uint64_t ticks, uint32_t flags);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_set_guard_period_64(const struct device * dev, uint64_t ticks, uint32_t flags)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { struct { uintptr_t lo, hi; } split; uint64_t val; } parm1 = { .val = ticks };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = flags };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.split.lo, parm1.split.hi, parm2.x, K_SYSCALL_COUNTER_SET_GUARD_PERIOD_64);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_set_guard_period_64(dev, ticks, flags);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_set_guard_period_64(dev, ticks, flags) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_SET_GUARD_PERIOD_64, counter_set_guard_period_64, dev, ticks, flags); syscall__retval = counter_set_guard_period_64(dev, ticks, flags); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_SET_GUARD_PERIOD_64, counter_set_guard_period_64, dev, ticks, flags, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint64_t z_impl_counter_get_guard_period_64(const struct device * dev, uint32_t flags);
|
||||
|
||||
__pinned_func
|
||||
static inline uint64_t counter_get_guard_period_64(const struct device * dev, uint32_t flags)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
uint64_t ret64;
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = flags };
|
||||
(void) arch_syscall_invoke3(parm0.x, parm1.x, (uintptr_t)&ret64, K_SYSCALL_COUNTER_GET_GUARD_PERIOD_64);
|
||||
return (uint64_t) ret64;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_guard_period_64(dev, flags);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_guard_period_64(dev, flags) ({ uint64_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_GUARD_PERIOD_64, counter_get_guard_period_64, dev, flags); syscall__retval = counter_get_guard_period_64(dev, flags); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_GUARD_PERIOD_64, counter_get_guard_period_64, dev, flags, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_get_value_64(const struct device * dev, uint64_t * ticks);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_get_value_64(const struct device * dev, uint64_t * ticks)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint64_t * val; } parm1 = { .val = ticks };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_GET_VALUE_64);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_value_64(dev, ticks);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_value_64(dev, ticks) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_VALUE_64, counter_get_value_64, dev, ticks); syscall__retval = counter_get_value_64(dev, ticks); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_VALUE_64, counter_get_value_64, dev, ticks, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_set_value_64(const struct device * dev, uint64_t ticks);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_set_value_64(const struct device * dev, uint64_t ticks)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { struct { uintptr_t lo, hi; } split; uint64_t val; } parm1 = { .val = ticks };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.split.lo, parm1.split.hi, K_SYSCALL_COUNTER_SET_VALUE_64);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_set_value_64(dev, ticks);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_set_value_64(dev, ticks) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_SET_VALUE_64, counter_set_value_64, dev, ticks); syscall__retval = counter_set_value_64(dev, ticks); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_SET_VALUE_64, counter_set_value_64, dev, ticks, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
102
build/zephyr/include/generated/zephyr/syscalls/crc.h
Normal file
102
build/zephyr/include/generated/zephyr/syscalls/crc.h
Normal file
@@ -0,0 +1,102 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_CRC_H
|
||||
#define Z_INCLUDE_SYSCALLS_CRC_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_crc_begin(const struct device * dev, struct crc_ctx * ctx);
|
||||
|
||||
__pinned_func
|
||||
static inline int crc_begin(const struct device * dev, struct crc_ctx * ctx)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct crc_ctx * val; } parm1 = { .val = ctx };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CRC_BEGIN);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_crc_begin(dev, ctx);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define crc_begin(dev, ctx) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CRC_BEGIN, crc_begin, dev, ctx); syscall__retval = crc_begin(dev, ctx); sys_port_trace_syscall_exit(K_SYSCALL_CRC_BEGIN, crc_begin, dev, ctx, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_crc_update(const struct device * dev, struct crc_ctx * ctx, const void * buffer, size_t bufsize);
|
||||
|
||||
__pinned_func
|
||||
static inline int crc_update(const struct device * dev, struct crc_ctx * ctx, const void * buffer, size_t bufsize)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct crc_ctx * val; } parm1 = { .val = ctx };
|
||||
union { uintptr_t x; const void * val; } parm2 = { .val = buffer };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = bufsize };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_CRC_UPDATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_crc_update(dev, ctx, buffer, bufsize);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define crc_update(dev, ctx, buffer, bufsize) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CRC_UPDATE, crc_update, dev, ctx, buffer, bufsize); syscall__retval = crc_update(dev, ctx, buffer, bufsize); sys_port_trace_syscall_exit(K_SYSCALL_CRC_UPDATE, crc_update, dev, ctx, buffer, bufsize, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_crc_finish(const struct device * dev, struct crc_ctx * ctx);
|
||||
|
||||
__pinned_func
|
||||
static inline int crc_finish(const struct device * dev, struct crc_ctx * ctx)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct crc_ctx * val; } parm1 = { .val = ctx };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CRC_FINISH);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_crc_finish(dev, ctx);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define crc_finish(dev, ctx) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CRC_FINISH, crc_finish, dev, ctx); syscall__retval = crc_finish(dev, ctx); sys_port_trace_syscall_exit(K_SYSCALL_CRC_FINISH, crc_finish, dev, ctx, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
77
build/zephyr/include/generated/zephyr/syscalls/dac.h
Normal file
77
build/zephyr/include/generated/zephyr/syscalls/dac.h
Normal file
@@ -0,0 +1,77 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_DAC_H
|
||||
#define Z_INCLUDE_SYSCALLS_DAC_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_dac_channel_setup(const struct device * dev, const struct dac_channel_cfg * channel_cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int dac_channel_setup(const struct device * dev, const struct dac_channel_cfg * channel_cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct dac_channel_cfg * val; } parm1 = { .val = channel_cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DAC_CHANNEL_SETUP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dac_channel_setup(dev, channel_cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dac_channel_setup(dev, channel_cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAC_CHANNEL_SETUP, dac_channel_setup, dev, channel_cfg); syscall__retval = dac_channel_setup(dev, channel_cfg); sys_port_trace_syscall_exit(K_SYSCALL_DAC_CHANNEL_SETUP, dac_channel_setup, dev, channel_cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_dac_write_value(const struct device * dev, uint8_t channel, uint32_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline int dac_write_value(const struct device * dev, uint8_t channel, uint32_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = channel };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = value };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_DAC_WRITE_VALUE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dac_write_value(dev, channel, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dac_write_value(dev, channel, value) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAC_WRITE_VALUE, dac_write_value, dev, channel, value); syscall__retval = dac_write_value(dev, channel, value); sys_port_trace_syscall_exit(K_SYSCALL_DAC_WRITE_VALUE, dac_write_value, dev, channel, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
298
build/zephyr/include/generated/zephyr/syscalls/dai.h
Normal file
298
build/zephyr/include/generated/zephyr/syscalls/dai.h
Normal file
@@ -0,0 +1,298 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_DAI_H
|
||||
#define Z_INCLUDE_SYSCALLS_DAI_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_dai_probe(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int dai_probe(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_DAI_PROBE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dai_probe(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dai_probe(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAI_PROBE, dai_probe, dev); syscall__retval = dai_probe(dev); sys_port_trace_syscall_exit(K_SYSCALL_DAI_PROBE, dai_probe, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_dai_remove(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int dai_remove(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_DAI_REMOVE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dai_remove(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dai_remove(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAI_REMOVE, dai_remove, dev); syscall__retval = dai_remove(dev); sys_port_trace_syscall_exit(K_SYSCALL_DAI_REMOVE, dai_remove, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_dai_config_set(const struct device * dev, const struct dai_config * cfg, const void * bespoke_cfg, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int dai_config_set(const struct device * dev, const struct dai_config * cfg, const void * bespoke_cfg, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct dai_config * val; } parm1 = { .val = cfg };
|
||||
union { uintptr_t x; const void * val; } parm2 = { .val = bespoke_cfg };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = size };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_DAI_CONFIG_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dai_config_set(dev, cfg, bespoke_cfg, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dai_config_set(dev, cfg, bespoke_cfg, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAI_CONFIG_SET, dai_config_set, dev, cfg, bespoke_cfg, size); syscall__retval = dai_config_set(dev, cfg, bespoke_cfg, size); sys_port_trace_syscall_exit(K_SYSCALL_DAI_CONFIG_SET, dai_config_set, dev, cfg, bespoke_cfg, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_dai_config_get(const struct device * dev, struct dai_config * cfg, enum dai_dir dir);
|
||||
|
||||
__pinned_func
|
||||
static inline int dai_config_get(const struct device * dev, struct dai_config * cfg, enum dai_dir dir)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct dai_config * val; } parm1 = { .val = cfg };
|
||||
union { uintptr_t x; enum dai_dir val; } parm2 = { .val = dir };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_DAI_CONFIG_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dai_config_get(dev, cfg, dir);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dai_config_get(dev, cfg, dir) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAI_CONFIG_GET, dai_config_get, dev, cfg, dir); syscall__retval = dai_config_get(dev, cfg, dir); sys_port_trace_syscall_exit(K_SYSCALL_DAI_CONFIG_GET, dai_config_get, dev, cfg, dir, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_dai_get_properties_copy(const struct device * dev, enum dai_dir dir, int stream_id, struct dai_properties * dst);
|
||||
|
||||
__pinned_func
|
||||
static inline int dai_get_properties_copy(const struct device * dev, enum dai_dir dir, int stream_id, struct dai_properties * dst)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum dai_dir val; } parm1 = { .val = dir };
|
||||
union { uintptr_t x; int val; } parm2 = { .val = stream_id };
|
||||
union { uintptr_t x; struct dai_properties * val; } parm3 = { .val = dst };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_DAI_GET_PROPERTIES_COPY);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dai_get_properties_copy(dev, dir, stream_id, dst);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dai_get_properties_copy(dev, dir, stream_id, dst) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAI_GET_PROPERTIES_COPY, dai_get_properties_copy, dev, dir, stream_id, dst); syscall__retval = dai_get_properties_copy(dev, dir, stream_id, dst); sys_port_trace_syscall_exit(K_SYSCALL_DAI_GET_PROPERTIES_COPY, dai_get_properties_copy, dev, dir, stream_id, dst, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_dai_trigger(const struct device * dev, enum dai_dir dir, enum dai_trigger_cmd cmd);
|
||||
|
||||
__pinned_func
|
||||
static inline int dai_trigger(const struct device * dev, enum dai_dir dir, enum dai_trigger_cmd cmd)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum dai_dir val; } parm1 = { .val = dir };
|
||||
union { uintptr_t x; enum dai_trigger_cmd val; } parm2 = { .val = cmd };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_DAI_TRIGGER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dai_trigger(dev, dir, cmd);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dai_trigger(dev, dir, cmd) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAI_TRIGGER, dai_trigger, dev, dir, cmd); syscall__retval = dai_trigger(dev, dir, cmd); sys_port_trace_syscall_exit(K_SYSCALL_DAI_TRIGGER, dai_trigger, dev, dir, cmd, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_dai_ts_config(const struct device * dev, struct dai_ts_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int dai_ts_config(const struct device * dev, struct dai_ts_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct dai_ts_cfg * val; } parm1 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DAI_TS_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dai_ts_config(dev, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dai_ts_config(dev, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAI_TS_CONFIG, dai_ts_config, dev, cfg); syscall__retval = dai_ts_config(dev, cfg); sys_port_trace_syscall_exit(K_SYSCALL_DAI_TS_CONFIG, dai_ts_config, dev, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_dai_ts_start(const struct device * dev, struct dai_ts_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int dai_ts_start(const struct device * dev, struct dai_ts_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct dai_ts_cfg * val; } parm1 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DAI_TS_START);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dai_ts_start(dev, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dai_ts_start(dev, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAI_TS_START, dai_ts_start, dev, cfg); syscall__retval = dai_ts_start(dev, cfg); sys_port_trace_syscall_exit(K_SYSCALL_DAI_TS_START, dai_ts_start, dev, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_dai_ts_stop(const struct device * dev, struct dai_ts_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int dai_ts_stop(const struct device * dev, struct dai_ts_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct dai_ts_cfg * val; } parm1 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DAI_TS_STOP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dai_ts_stop(dev, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dai_ts_stop(dev, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAI_TS_STOP, dai_ts_stop, dev, cfg); syscall__retval = dai_ts_stop(dev, cfg); sys_port_trace_syscall_exit(K_SYSCALL_DAI_TS_STOP, dai_ts_stop, dev, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_dai_ts_get(const struct device * dev, struct dai_ts_cfg * cfg, struct dai_ts_data * tsd);
|
||||
|
||||
__pinned_func
|
||||
static inline int dai_ts_get(const struct device * dev, struct dai_ts_cfg * cfg, struct dai_ts_data * tsd)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct dai_ts_cfg * val; } parm1 = { .val = cfg };
|
||||
union { uintptr_t x; struct dai_ts_data * val; } parm2 = { .val = tsd };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_DAI_TS_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dai_ts_get(dev, cfg, tsd);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dai_ts_get(dev, cfg, tsd) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAI_TS_GET, dai_ts_get, dev, cfg, tsd); syscall__retval = dai_ts_get(dev, cfg, tsd); sys_port_trace_syscall_exit(K_SYSCALL_DAI_TS_GET, dai_ts_get, dev, cfg, tsd, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_dai_config_update(const struct device * dev, const void * bespoke_cfg, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int dai_config_update(const struct device * dev, const void * bespoke_cfg, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const void * val; } parm1 = { .val = bespoke_cfg };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = size };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_DAI_CONFIG_UPDATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dai_config_update(dev, bespoke_cfg, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dai_config_update(dev, bespoke_cfg, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAI_CONFIG_UPDATE, dai_config_update, dev, bespoke_cfg, size); syscall__retval = dai_config_update(dev, bespoke_cfg, size); sys_port_trace_syscall_exit(K_SYSCALL_DAI_CONFIG_UPDATE, dai_config_update, dev, bespoke_cfg, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
149
build/zephyr/include/generated/zephyr/syscalls/demand_paging.h
Normal file
149
build/zephyr/include/generated/zephyr/syscalls/demand_paging.h
Normal file
@@ -0,0 +1,149 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_DEMAND_PAGING_H
|
||||
#define Z_INCLUDE_SYSCALLS_DEMAND_PAGING_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_k_mem_paging_stats_get(struct k_mem_paging_stats_t * stats);
|
||||
|
||||
__pinned_func
|
||||
static inline void k_mem_paging_stats_get(struct k_mem_paging_stats_t * stats)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct k_mem_paging_stats_t * val; } parm0 = { .val = stats };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MEM_PAGING_STATS_GET);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_k_mem_paging_stats_get(stats);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_mem_paging_stats_get(stats) do { sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_STATS_GET, k_mem_paging_stats_get, stats); k_mem_paging_stats_get(stats); sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_STATS_GET, k_mem_paging_stats_get, stats); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_k_mem_paging_thread_stats_get(struct k_thread * thread, struct k_mem_paging_stats_t * stats);
|
||||
|
||||
__pinned_func
|
||||
static inline void k_mem_paging_thread_stats_get(struct k_thread * thread, struct k_mem_paging_stats_t * stats)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct k_thread * val; } parm0 = { .val = thread };
|
||||
union { uintptr_t x; struct k_mem_paging_stats_t * val; } parm1 = { .val = stats };
|
||||
(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_k_mem_paging_thread_stats_get(thread, stats);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_mem_paging_thread_stats_get(thread, stats) do { sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET, k_mem_paging_thread_stats_get, thread, stats); k_mem_paging_thread_stats_get(thread, stats); sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET, k_mem_paging_thread_stats_get, thread, stats); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_k_mem_paging_histogram_eviction_get(struct k_mem_paging_histogram_t * hist);
|
||||
|
||||
__pinned_func
|
||||
static inline void k_mem_paging_histogram_eviction_get(struct k_mem_paging_histogram_t * hist)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct k_mem_paging_histogram_t * val; } parm0 = { .val = hist };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_k_mem_paging_histogram_eviction_get(hist);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_mem_paging_histogram_eviction_get(hist) do { sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET, k_mem_paging_histogram_eviction_get, hist); k_mem_paging_histogram_eviction_get(hist); sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET, k_mem_paging_histogram_eviction_get, hist); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_k_mem_paging_histogram_backing_store_page_in_get(struct k_mem_paging_histogram_t * hist);
|
||||
|
||||
__pinned_func
|
||||
static inline void k_mem_paging_histogram_backing_store_page_in_get(struct k_mem_paging_histogram_t * hist)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct k_mem_paging_histogram_t * val; } parm0 = { .val = hist };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_k_mem_paging_histogram_backing_store_page_in_get(hist);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_mem_paging_histogram_backing_store_page_in_get(hist) do { sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET, k_mem_paging_histogram_backing_store_page_in_get, hist); k_mem_paging_histogram_backing_store_page_in_get(hist); sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET, k_mem_paging_histogram_backing_store_page_in_get, hist); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_k_mem_paging_histogram_backing_store_page_out_get(struct k_mem_paging_histogram_t * hist);
|
||||
|
||||
__pinned_func
|
||||
static inline void k_mem_paging_histogram_backing_store_page_out_get(struct k_mem_paging_histogram_t * hist)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct k_mem_paging_histogram_t * val; } parm0 = { .val = hist };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_k_mem_paging_histogram_backing_store_page_out_get(hist);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_mem_paging_histogram_backing_store_page_out_get(hist) do { sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET, k_mem_paging_histogram_backing_store_page_out_get, hist); k_mem_paging_histogram_backing_store_page_out_get(hist); sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET, k_mem_paging_histogram_backing_store_page_out_get, hist); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
143
build/zephyr/include/generated/zephyr/syscalls/device.h
Normal file
143
build/zephyr/include/generated/zephyr/syscalls/device.h
Normal file
@@ -0,0 +1,143 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_DEVICE_H
|
||||
#define Z_INCLUDE_SYSCALLS_DEVICE_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern const struct device * z_impl_device_get_binding(const char * name);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct device * device_get_binding(const char * name)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const char * val; } parm0 = { .val = name };
|
||||
return (const struct device *) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVICE_GET_BINDING);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_device_get_binding(name);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define device_get_binding(name) ({ const struct device * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DEVICE_GET_BINDING, device_get_binding, name); syscall__retval = device_get_binding(name); sys_port_trace_syscall_exit(K_SYSCALL_DEVICE_GET_BINDING, device_get_binding, name, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_device_is_ready(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline bool device_is_ready(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (bool) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVICE_IS_READY);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_device_is_ready(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define device_is_ready(dev) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DEVICE_IS_READY, device_is_ready, dev); syscall__retval = device_is_ready(dev); sys_port_trace_syscall_exit(K_SYSCALL_DEVICE_IS_READY, device_is_ready, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_device_init(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int device_init(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVICE_INIT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_device_init(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define device_init(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DEVICE_INIT, device_init, dev); syscall__retval = device_init(dev); sys_port_trace_syscall_exit(K_SYSCALL_DEVICE_INIT, device_init, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_device_deinit(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int device_deinit(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVICE_DEINIT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_device_deinit(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define device_deinit(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DEVICE_DEINIT, device_deinit, dev); syscall__retval = device_deinit(dev); sys_port_trace_syscall_exit(K_SYSCALL_DEVICE_DEINIT, device_deinit, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern const struct device * z_impl_device_get_by_dt_nodelabel(const char * nodelabel);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct device * device_get_by_dt_nodelabel(const char * nodelabel)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const char * val; } parm0 = { .val = nodelabel };
|
||||
return (const struct device *) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVICE_GET_BY_DT_NODELABEL);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_device_get_by_dt_nodelabel(nodelabel);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define device_get_by_dt_nodelabel(nodelabel) ({ const struct device * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DEVICE_GET_BY_DT_NODELABEL, device_get_by_dt_nodelabel, nodelabel); syscall__retval = device_get_by_dt_nodelabel(nodelabel); sys_port_trace_syscall_exit(K_SYSCALL_DEVICE_GET_BY_DT_NODELABEL, device_get_by_dt_nodelabel, nodelabel, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
75
build/zephyr/include/generated/zephyr/syscalls/devmux.h
Normal file
75
build/zephyr/include/generated/zephyr/syscalls/devmux.h
Normal file
@@ -0,0 +1,75 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_DEVMUX_H
|
||||
#define Z_INCLUDE_SYSCALLS_DEVMUX_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_devmux_select_get(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int devmux_select_get(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVMUX_SELECT_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_devmux_select_get(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define devmux_select_get(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DEVMUX_SELECT_GET, devmux_select_get, dev); syscall__retval = devmux_select_get(dev); sys_port_trace_syscall_exit(K_SYSCALL_DEVMUX_SELECT_GET, devmux_select_get, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_devmux_select_set(struct device * dev, size_t index);
|
||||
|
||||
__pinned_func
|
||||
static inline int devmux_select_set(struct device * dev, size_t index)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = index };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DEVMUX_SELECT_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_devmux_select_set(dev, index);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define devmux_select_set(dev, index) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DEVMUX_SELECT_SET, devmux_select_set, dev, index); syscall__retval = devmux_select_set(dev, index); sys_port_trace_syscall_exit(K_SYSCALL_DEVMUX_SELECT_SET, devmux_select_set, dev, index, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
103
build/zephyr/include/generated/zephyr/syscalls/eeprom.h
Normal file
103
build/zephyr/include/generated/zephyr/syscalls/eeprom.h
Normal file
@@ -0,0 +1,103 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_EEPROM_H
|
||||
#define Z_INCLUDE_SYSCALLS_EEPROM_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_eeprom_read(const struct device * dev, off_t offset, void * data, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int eeprom_read(const struct device * dev, off_t offset, void * data, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; void * val; } parm2 = { .val = data };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_EEPROM_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_eeprom_read(dev, offset, data, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define eeprom_read(dev, offset, data, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_EEPROM_READ, eeprom_read, dev, offset, data, len); syscall__retval = eeprom_read(dev, offset, data, len); sys_port_trace_syscall_exit(K_SYSCALL_EEPROM_READ, eeprom_read, dev, offset, data, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_eeprom_write(const struct device * dev, off_t offset, const void * data, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int eeprom_write(const struct device * dev, off_t offset, const void * data, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; const void * val; } parm2 = { .val = data };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_EEPROM_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_eeprom_write(dev, offset, data, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define eeprom_write(dev, offset, data, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_EEPROM_WRITE, eeprom_write, dev, offset, data, len); syscall__retval = eeprom_write(dev, offset, data, len); sys_port_trace_syscall_exit(K_SYSCALL_EEPROM_WRITE, eeprom_write, dev, offset, data, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern size_t z_impl_eeprom_get_size(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline size_t eeprom_get_size(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (size_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_EEPROM_GET_SIZE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_eeprom_get_size(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define eeprom_get_size(dev) ({ size_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_EEPROM_GET_SIZE, eeprom_get_size, dev); syscall__retval = eeprom_get_size(dev); sys_port_trace_syscall_exit(K_SYSCALL_EEPROM_GET_SIZE, eeprom_get_size, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,77 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_EMUL_FUEL_GAUGE_H
|
||||
#define Z_INCLUDE_SYSCALLS_EMUL_FUEL_GAUGE_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_emul_fuel_gauge_set_battery_charging(const struct emul * target, uint32_t uV, int uA);
|
||||
|
||||
__pinned_func
|
||||
static inline int emul_fuel_gauge_set_battery_charging(const struct emul * target, uint32_t uV, int uA)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct emul * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = uV };
|
||||
union { uintptr_t x; int val; } parm2 = { .val = uA };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_emul_fuel_gauge_set_battery_charging(target, uV, uA);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define emul_fuel_gauge_set_battery_charging(target, uV, uA) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING, emul_fuel_gauge_set_battery_charging, target, uV, uA); syscall__retval = emul_fuel_gauge_set_battery_charging(target, uV, uA); sys_port_trace_syscall_exit(K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING, emul_fuel_gauge_set_battery_charging, target, uV, uA, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_emul_fuel_gauge_is_battery_cutoff(const struct emul * target, bool * cutoff);
|
||||
|
||||
__pinned_func
|
||||
static inline int emul_fuel_gauge_is_battery_cutoff(const struct emul * target, bool * cutoff)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct emul * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; bool * val; } parm1 = { .val = cutoff };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_emul_fuel_gauge_is_battery_cutoff(target, cutoff);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define emul_fuel_gauge_is_battery_cutoff(target, cutoff) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF, emul_fuel_gauge_is_battery_cutoff, target, cutoff); syscall__retval = emul_fuel_gauge_is_battery_cutoff(target, cutoff); sys_port_trace_syscall_exit(K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF, emul_fuel_gauge_is_battery_cutoff, target, cutoff, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
53
build/zephyr/include/generated/zephyr/syscalls/entropy.h
Normal file
53
build/zephyr/include/generated/zephyr/syscalls/entropy.h
Normal file
@@ -0,0 +1,53 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ENTROPY_H
|
||||
#define Z_INCLUDE_SYSCALLS_ENTROPY_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_entropy_get_entropy(const struct device * dev, uint8_t * buffer, uint16_t length);
|
||||
|
||||
__pinned_func
|
||||
static inline int entropy_get_entropy(const struct device * dev, uint8_t * buffer, uint16_t length)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t * val; } parm1 = { .val = buffer };
|
||||
union { uintptr_t x; uint16_t val; } parm2 = { .val = length };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ENTROPY_GET_ENTROPY);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_entropy_get_entropy(dev, buffer, length);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define entropy_get_entropy(dev, buffer, length) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ENTROPY_GET_ENTROPY, entropy_get_entropy, dev, buffer, length); syscall__retval = entropy_get_entropy(dev, buffer, length); sys_port_trace_syscall_exit(K_SYSCALL_ENTROPY_GET_ENTROPY, entropy_get_entropy, dev, buffer, length, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,43 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ERRNO_PRIVATE_H
|
||||
#define Z_INCLUDE_SYSCALLS_ERRNO_PRIVATE_H
|
||||
|
||||
|
||||
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int * z_impl_z_errno(void);
|
||||
|
||||
__pinned_func
|
||||
static inline int * z_errno(void)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
return (int *) arch_syscall_invoke0(K_SYSCALL_Z_ERRNO);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_z_errno();
|
||||
}
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
52
build/zephyr/include/generated/zephyr/syscalls/error.h
Normal file
52
build/zephyr/include/generated/zephyr/syscalls/error.h
Normal file
@@ -0,0 +1,52 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ERROR_H
|
||||
#define Z_INCLUDE_SYSCALLS_ERROR_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_user_fault(unsigned int reason);
|
||||
|
||||
__pinned_func
|
||||
static inline void user_fault(unsigned int reason)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; unsigned int val; } parm0 = { .val = reason };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_USER_FAULT);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_user_fault(reason);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define user_fault(reason) do { sys_port_trace_syscall_enter(K_SYSCALL_USER_FAULT, user_fault, reason); user_fault(reason); sys_port_trace_syscall_exit(K_SYSCALL_USER_FAULT, user_fault, reason); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
344
build/zephyr/include/generated/zephyr/syscalls/espi.h
Normal file
344
build/zephyr/include/generated/zephyr/syscalls/espi.h
Normal file
@@ -0,0 +1,344 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ESPI_H
|
||||
#define Z_INCLUDE_SYSCALLS_ESPI_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_espi_config(const struct device * dev, struct espi_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_config(const struct device * dev, struct espi_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_cfg * val; } parm1 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_config(dev, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_config(dev, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_CONFIG, espi_config, dev, cfg); syscall__retval = espi_config(dev, cfg); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_CONFIG, espi_config, dev, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_espi_get_channel_status(const struct device * dev, enum espi_channel ch);
|
||||
|
||||
__pinned_func
|
||||
static inline bool espi_get_channel_status(const struct device * dev, enum espi_channel ch)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum espi_channel val; } parm1 = { .val = ch };
|
||||
return (bool) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_GET_CHANNEL_STATUS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_get_channel_status(dev, ch);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_get_channel_status(dev, ch) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_GET_CHANNEL_STATUS, espi_get_channel_status, dev, ch); syscall__retval = espi_get_channel_status(dev, ch); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_GET_CHANNEL_STATUS, espi_get_channel_status, dev, ch, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_read_request(const struct device * dev, struct espi_request_packet * req);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_read_request(const struct device * dev, struct espi_request_packet * req)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_request_packet * val; } parm1 = { .val = req };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_READ_REQUEST);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_read_request(dev, req);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_read_request(dev, req) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_READ_REQUEST, espi_read_request, dev, req); syscall__retval = espi_read_request(dev, req); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_READ_REQUEST, espi_read_request, dev, req, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_write_request(const struct device * dev, struct espi_request_packet * req);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_write_request(const struct device * dev, struct espi_request_packet * req)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_request_packet * val; } parm1 = { .val = req };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_WRITE_REQUEST);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_write_request(dev, req);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_write_request(dev, req) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_WRITE_REQUEST, espi_write_request, dev, req); syscall__retval = espi_write_request(dev, req); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_WRITE_REQUEST, espi_write_request, dev, req, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_read_lpc_request(const struct device * dev, enum lpc_peripheral_opcode op, uint32_t * data);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_read_lpc_request(const struct device * dev, enum lpc_peripheral_opcode op, uint32_t * data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum lpc_peripheral_opcode val; } parm1 = { .val = op };
|
||||
union { uintptr_t x; uint32_t * val; } parm2 = { .val = data };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ESPI_READ_LPC_REQUEST);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_read_lpc_request(dev, op, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_read_lpc_request(dev, op, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_READ_LPC_REQUEST, espi_read_lpc_request, dev, op, data); syscall__retval = espi_read_lpc_request(dev, op, data); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_READ_LPC_REQUEST, espi_read_lpc_request, dev, op, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_write_lpc_request(const struct device * dev, enum lpc_peripheral_opcode op, uint32_t * data);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_write_lpc_request(const struct device * dev, enum lpc_peripheral_opcode op, uint32_t * data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum lpc_peripheral_opcode val; } parm1 = { .val = op };
|
||||
union { uintptr_t x; uint32_t * val; } parm2 = { .val = data };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ESPI_WRITE_LPC_REQUEST);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_write_lpc_request(dev, op, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_write_lpc_request(dev, op, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_WRITE_LPC_REQUEST, espi_write_lpc_request, dev, op, data); syscall__retval = espi_write_lpc_request(dev, op, data); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_WRITE_LPC_REQUEST, espi_write_lpc_request, dev, op, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_send_vwire(const struct device * dev, enum espi_vwire_signal signal, uint8_t level);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_send_vwire(const struct device * dev, enum espi_vwire_signal signal, uint8_t level)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum espi_vwire_signal val; } parm1 = { .val = signal };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = level };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ESPI_SEND_VWIRE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_send_vwire(dev, signal, level);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_send_vwire(dev, signal, level) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SEND_VWIRE, espi_send_vwire, dev, signal, level); syscall__retval = espi_send_vwire(dev, signal, level); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SEND_VWIRE, espi_send_vwire, dev, signal, level, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_receive_vwire(const struct device * dev, enum espi_vwire_signal signal, uint8_t * level);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_receive_vwire(const struct device * dev, enum espi_vwire_signal signal, uint8_t * level)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum espi_vwire_signal val; } parm1 = { .val = signal };
|
||||
union { uintptr_t x; uint8_t * val; } parm2 = { .val = level };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ESPI_RECEIVE_VWIRE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_receive_vwire(dev, signal, level);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_receive_vwire(dev, signal, level) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_RECEIVE_VWIRE, espi_receive_vwire, dev, signal, level); syscall__retval = espi_receive_vwire(dev, signal, level); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_RECEIVE_VWIRE, espi_receive_vwire, dev, signal, level, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_send_oob(const struct device * dev, struct espi_oob_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_send_oob(const struct device * dev, struct espi_oob_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_oob_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SEND_OOB);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_send_oob(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_send_oob(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SEND_OOB, espi_send_oob, dev, pckt); syscall__retval = espi_send_oob(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SEND_OOB, espi_send_oob, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_receive_oob(const struct device * dev, struct espi_oob_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_receive_oob(const struct device * dev, struct espi_oob_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_oob_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_RECEIVE_OOB);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_receive_oob(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_receive_oob(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_RECEIVE_OOB, espi_receive_oob, dev, pckt); syscall__retval = espi_receive_oob(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_RECEIVE_OOB, espi_receive_oob, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_read_flash(const struct device * dev, struct espi_flash_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_read_flash(const struct device * dev, struct espi_flash_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_flash_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_READ_FLASH);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_read_flash(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_read_flash(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_READ_FLASH, espi_read_flash, dev, pckt); syscall__retval = espi_read_flash(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_READ_FLASH, espi_read_flash, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_write_flash(const struct device * dev, struct espi_flash_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_write_flash(const struct device * dev, struct espi_flash_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_flash_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_WRITE_FLASH);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_write_flash(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_write_flash(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_WRITE_FLASH, espi_write_flash, dev, pckt); syscall__retval = espi_write_flash(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_WRITE_FLASH, espi_write_flash, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_flash_erase(const struct device * dev, struct espi_flash_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_flash_erase(const struct device * dev, struct espi_flash_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_flash_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_FLASH_ERASE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_flash_erase(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_flash_erase(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_FLASH_ERASE, espi_flash_erase, dev, pckt); syscall__retval = espi_flash_erase(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_FLASH_ERASE, espi_flash_erase, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
218
build/zephyr/include/generated/zephyr/syscalls/espi_saf.h
Normal file
218
build/zephyr/include/generated/zephyr/syscalls/espi_saf.h
Normal file
@@ -0,0 +1,218 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ESPI_SAF_H
|
||||
#define Z_INCLUDE_SYSCALLS_ESPI_SAF_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_espi_saf_config(const struct device * dev, const struct espi_saf_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_saf_config(const struct device * dev, const struct espi_saf_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct espi_saf_cfg * val; } parm1 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_config(dev, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_config(dev, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_CONFIG, espi_saf_config, dev, cfg); syscall__retval = espi_saf_config(dev, cfg); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_CONFIG, espi_saf_config, dev, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_saf_set_protection_regions(const struct device * dev, const struct espi_saf_protection * pr);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_saf_set_protection_regions(const struct device * dev, const struct espi_saf_protection * pr)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct espi_saf_protection * val; } parm1 = { .val = pr };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_set_protection_regions(dev, pr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_set_protection_regions(dev, pr) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS, espi_saf_set_protection_regions, dev, pr); syscall__retval = espi_saf_set_protection_regions(dev, pr); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS, espi_saf_set_protection_regions, dev, pr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_saf_activate(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_saf_activate(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_ESPI_SAF_ACTIVATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_activate(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_activate(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_ACTIVATE, espi_saf_activate, dev); syscall__retval = espi_saf_activate(dev); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_ACTIVATE, espi_saf_activate, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_espi_saf_get_channel_status(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline bool espi_saf_get_channel_status(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (bool) arch_syscall_invoke1(parm0.x, K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_get_channel_status(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_get_channel_status(dev) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS, espi_saf_get_channel_status, dev); syscall__retval = espi_saf_get_channel_status(dev); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS, espi_saf_get_channel_status, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_saf_flash_read(const struct device * dev, struct espi_saf_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_saf_flash_read(const struct device * dev, struct espi_saf_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_saf_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_FLASH_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_flash_read(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_flash_read(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_FLASH_READ, espi_saf_flash_read, dev, pckt); syscall__retval = espi_saf_flash_read(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_FLASH_READ, espi_saf_flash_read, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_saf_flash_write(const struct device * dev, struct espi_saf_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_saf_flash_write(const struct device * dev, struct espi_saf_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_saf_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_FLASH_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_flash_write(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_flash_write(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_FLASH_WRITE, espi_saf_flash_write, dev, pckt); syscall__retval = espi_saf_flash_write(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_FLASH_WRITE, espi_saf_flash_write, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_saf_flash_erase(const struct device * dev, struct espi_saf_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_saf_flash_erase(const struct device * dev, struct espi_saf_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_saf_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_FLASH_ERASE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_flash_erase(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_flash_erase(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_FLASH_ERASE, espi_saf_flash_erase, dev, pckt); syscall__retval = espi_saf_flash_erase(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_FLASH_ERASE, espi_saf_flash_erase, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_saf_flash_unsuccess(const struct device * dev, struct espi_saf_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_saf_flash_unsuccess(const struct device * dev, struct espi_saf_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_saf_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_flash_unsuccess(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_flash_unsuccess(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS, espi_saf_flash_unsuccess, dev, pckt); syscall__retval = espi_saf_flash_unsuccess(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS, espi_saf_flash_unsuccess, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
51
build/zephyr/include/generated/zephyr/syscalls/ethernet.h
Normal file
51
build/zephyr/include/generated/zephyr/syscalls/ethernet.h
Normal file
@@ -0,0 +1,51 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ETHERNET_H
|
||||
#define Z_INCLUDE_SYSCALLS_ETHERNET_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern const struct device * z_impl_net_eth_get_ptp_clock_by_index(int index);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct device * net_eth_get_ptp_clock_by_index(int index)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = index };
|
||||
return (const struct device *) arch_syscall_invoke1(parm0.x, K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_eth_get_ptp_clock_by_index(index);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_eth_get_ptp_clock_by_index(index) ({ const struct device * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX, net_eth_get_ptp_clock_by_index, index); syscall__retval = net_eth_get_ptp_clock_by_index(index); sys_port_trace_syscall_exit(K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX, net_eth_get_ptp_clock_by_index, index, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
81
build/zephyr/include/generated/zephyr/syscalls/fdtable.h
Normal file
81
build/zephyr/include/generated/zephyr/syscalls/fdtable.h
Normal file
@@ -0,0 +1,81 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_FDTABLE_H
|
||||
#define Z_INCLUDE_SYSCALLS_FDTABLE_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_zvfs_poll(struct zvfs_pollfd * fds, int nfds, int poll_timeout);
|
||||
|
||||
__pinned_func
|
||||
static inline int zvfs_poll(struct zvfs_pollfd * fds, int nfds, int poll_timeout)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct zvfs_pollfd * val; } parm0 = { .val = fds };
|
||||
union { uintptr_t x; int val; } parm1 = { .val = nfds };
|
||||
union { uintptr_t x; int val; } parm2 = { .val = poll_timeout };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ZVFS_POLL);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_zvfs_poll(fds, nfds, poll_timeout);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define zvfs_poll(fds, nfds, poll_timeout) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ZVFS_POLL, zvfs_poll, fds, nfds, poll_timeout); syscall__retval = zvfs_poll(fds, nfds, poll_timeout); sys_port_trace_syscall_exit(K_SYSCALL_ZVFS_POLL, zvfs_poll, fds, nfds, poll_timeout, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_zvfs_select(int nfds, struct zvfs_fd_set *ZRESTRICT readfds, struct zvfs_fd_set *ZRESTRICT writefds, struct zvfs_fd_set *ZRESTRICT errorfds, const struct timespec *ZRESTRICT timeout, const void *ZRESTRICT sigmask);
|
||||
|
||||
__pinned_func
|
||||
static inline int zvfs_select(int nfds, struct zvfs_fd_set *ZRESTRICT readfds, struct zvfs_fd_set *ZRESTRICT writefds, struct zvfs_fd_set *ZRESTRICT errorfds, const struct timespec *ZRESTRICT timeout, const void *ZRESTRICT sigmask)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = nfds };
|
||||
union { uintptr_t x; struct zvfs_fd_set *ZRESTRICT val; } parm1 = { .val = readfds };
|
||||
union { uintptr_t x; struct zvfs_fd_set *ZRESTRICT val; } parm2 = { .val = writefds };
|
||||
union { uintptr_t x; struct zvfs_fd_set *ZRESTRICT val; } parm3 = { .val = errorfds };
|
||||
union { uintptr_t x; const struct timespec *ZRESTRICT val; } parm4 = { .val = timeout };
|
||||
union { uintptr_t x; const void *ZRESTRICT val; } parm5 = { .val = sigmask };
|
||||
return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, parm5.x, K_SYSCALL_ZVFS_SELECT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_zvfs_select(nfds, readfds, writefds, errorfds, timeout, sigmask);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define zvfs_select(nfds, readfds, writefds, errorfds, timeout, sigmask) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ZVFS_SELECT, zvfs_select, nfds, readfds, writefds, errorfds, timeout, sigmask); syscall__retval = zvfs_select(nfds, readfds, writefds, errorfds, timeout, sigmask); sys_port_trace_syscall_exit(K_SYSCALL_ZVFS_SELECT, zvfs_select, nfds, readfds, writefds, errorfds, timeout, sigmask, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
408
build/zephyr/include/generated/zephyr/syscalls/flash.h
Normal file
408
build/zephyr/include/generated/zephyr/syscalls/flash.h
Normal file
@@ -0,0 +1,408 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_FLASH_H
|
||||
#define Z_INCLUDE_SYSCALLS_FLASH_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_flash_read(const struct device * dev, off_t offset, void * data, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_read(const struct device * dev, off_t offset, void * data, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; void * val; } parm2 = { .val = data };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FLASH_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_read(dev, offset, data, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_read(dev, offset, data, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_READ, flash_read, dev, offset, data, len); syscall__retval = flash_read(dev, offset, data, len); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_READ, flash_read, dev, offset, data, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_write(const struct device * dev, off_t offset, const void * data, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_write(const struct device * dev, off_t offset, const void * data, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; const void * val; } parm2 = { .val = data };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FLASH_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_write(dev, offset, data, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_write(dev, offset, data, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_WRITE, flash_write, dev, offset, data, len); syscall__retval = flash_write(dev, offset, data, len); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_WRITE, flash_write, dev, offset, data, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_erase(const struct device * dev, off_t offset, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_erase(const struct device * dev, off_t offset, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = size };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FLASH_ERASE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_erase(dev, offset, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_erase(dev, offset, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_ERASE, flash_erase, dev, offset, size); syscall__retval = flash_erase(dev, offset, size); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_ERASE, flash_erase, dev, offset, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_get_size(const struct device * dev, uint64_t * size);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_get_size(const struct device * dev, uint64_t * size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint64_t * val; } parm1 = { .val = size };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_FLASH_GET_SIZE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_get_size(dev, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_get_size(dev, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_SIZE, flash_get_size, dev, size); syscall__retval = flash_get_size(dev, size); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_SIZE, flash_get_size, dev, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_fill(const struct device * dev, uint8_t val, off_t offset, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_fill(const struct device * dev, uint8_t val, off_t offset, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = val };
|
||||
union { uintptr_t x; off_t val; } parm2 = { .val = offset };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = size };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FLASH_FILL);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_fill(dev, val, offset, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_fill(dev, val, offset, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_FILL, flash_fill, dev, val, offset, size); syscall__retval = flash_fill(dev, val, offset, size); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_FILL, flash_fill, dev, val, offset, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_flatten(const struct device * dev, off_t offset, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_flatten(const struct device * dev, off_t offset, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = size };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FLASH_FLATTEN);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_flatten(dev, offset, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_flatten(dev, offset, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_FLATTEN, flash_flatten, dev, offset, size); syscall__retval = flash_flatten(dev, offset, size); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_FLATTEN, flash_flatten, dev, offset, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_get_page_info_by_offs(const struct device * dev, off_t offset, struct flash_pages_info * info);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_get_page_info_by_offs(const struct device * dev, off_t offset, struct flash_pages_info * info)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; struct flash_pages_info * val; } parm2 = { .val = info };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_get_page_info_by_offs(dev, offset, info);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_get_page_info_by_offs(dev, offset, info) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS, flash_get_page_info_by_offs, dev, offset, info); syscall__retval = flash_get_page_info_by_offs(dev, offset, info); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS, flash_get_page_info_by_offs, dev, offset, info, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_get_page_info_by_idx(const struct device * dev, uint32_t page_index, struct flash_pages_info * info);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_get_page_info_by_idx(const struct device * dev, uint32_t page_index, struct flash_pages_info * info)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = page_index };
|
||||
union { uintptr_t x; struct flash_pages_info * val; } parm2 = { .val = info };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_get_page_info_by_idx(dev, page_index, info);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_get_page_info_by_idx(dev, page_index, info) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX, flash_get_page_info_by_idx, dev, page_index, info); syscall__retval = flash_get_page_info_by_idx(dev, page_index, info); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX, flash_get_page_info_by_idx, dev, page_index, info, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern size_t z_impl_flash_get_page_count(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline size_t flash_get_page_count(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (size_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_FLASH_GET_PAGE_COUNT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_get_page_count(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_get_page_count(dev) ({ size_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_PAGE_COUNT, flash_get_page_count, dev); syscall__retval = flash_get_page_count(dev); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_PAGE_COUNT, flash_get_page_count, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_sfdp_read(const struct device * dev, off_t offset, void * data, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_sfdp_read(const struct device * dev, off_t offset, void * data, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; void * val; } parm2 = { .val = data };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FLASH_SFDP_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_sfdp_read(dev, offset, data, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_sfdp_read(dev, offset, data, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_SFDP_READ, flash_sfdp_read, dev, offset, data, len); syscall__retval = flash_sfdp_read(dev, offset, data, len); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_SFDP_READ, flash_sfdp_read, dev, offset, data, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_read_jedec_id(const struct device * dev, uint8_t * id);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_read_jedec_id(const struct device * dev, uint8_t * id)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t * val; } parm1 = { .val = id };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_FLASH_READ_JEDEC_ID);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_read_jedec_id(dev, id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_read_jedec_id(dev, id) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_READ_JEDEC_ID, flash_read_jedec_id, dev, id); syscall__retval = flash_read_jedec_id(dev, id); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_READ_JEDEC_ID, flash_read_jedec_id, dev, id, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern size_t z_impl_flash_get_write_block_size(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline size_t flash_get_write_block_size(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (size_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_get_write_block_size(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_get_write_block_size(dev) ({ size_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE, flash_get_write_block_size, dev); syscall__retval = flash_get_write_block_size(dev); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE, flash_get_write_block_size, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern const struct flash_parameters * z_impl_flash_get_parameters(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct flash_parameters * flash_get_parameters(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (const struct flash_parameters *) arch_syscall_invoke1(parm0.x, K_SYSCALL_FLASH_GET_PARAMETERS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_get_parameters(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_get_parameters(dev) ({ const struct flash_parameters * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_PARAMETERS, flash_get_parameters, dev); syscall__retval = flash_get_parameters(dev); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_PARAMETERS, flash_get_parameters, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_ex_op(const struct device * dev, uint16_t code, const uintptr_t in, void * out);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_ex_op(const struct device * dev, uint16_t code, const uintptr_t in, void * out)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint16_t val; } parm1 = { .val = code };
|
||||
union { uintptr_t x; const uintptr_t val; } parm2 = { .val = in };
|
||||
union { uintptr_t x; void * val; } parm3 = { .val = out };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FLASH_EX_OP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_ex_op(dev, code, in, out);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_ex_op(dev, code, in, out) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_EX_OP, flash_ex_op, dev, code, in, out); syscall__retval = flash_ex_op(dev, code, in, out); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_EX_OP, flash_ex_op, dev, code, in, out, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_copy(const struct device * src_dev, off_t src_offset, const struct device * dst_dev, off_t dst_offset, off_t size, uint8_t * buf, size_t buf_size);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_copy(const struct device * src_dev, off_t src_offset, const struct device * dst_dev, off_t dst_offset, off_t size, uint8_t * buf, size_t buf_size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = src_dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = src_offset };
|
||||
union { uintptr_t x; const struct device * val; } parm2 = { .val = dst_dev };
|
||||
union { uintptr_t x; off_t val; } parm3 = { .val = dst_offset };
|
||||
union { uintptr_t x; off_t val; } parm4 = { .val = size };
|
||||
union { uintptr_t x; uint8_t * val; } parm5 = { .val = buf };
|
||||
union { uintptr_t x; size_t val; } parm6 = { .val = buf_size };
|
||||
uintptr_t more[] = {
|
||||
parm5.x,
|
||||
parm6.x
|
||||
};
|
||||
return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, (uintptr_t) &more, K_SYSCALL_FLASH_COPY);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_copy(src_dev, src_offset, dst_dev, dst_offset, size, buf, buf_size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_copy(src_dev, src_offset, dst_dev, dst_offset, size, buf, buf_size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_COPY, flash_copy, src_dev, src_offset, dst_dev, dst_offset, size, buf, buf_size); syscall__retval = flash_copy(src_dev, src_offset, dst_dev, dst_offset, size, buf, buf_size); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_COPY, flash_copy, src_dev, src_offset, dst_dev, dst_offset, size, buf, buf_size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
100
build/zephyr/include/generated/zephyr/syscalls/flash_simulator.h
Normal file
100
build/zephyr/include/generated/zephyr/syscalls/flash_simulator.h
Normal file
@@ -0,0 +1,100 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_FLASH_SIMULATOR_H
|
||||
#define Z_INCLUDE_SYSCALLS_FLASH_SIMULATOR_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern const struct flash_simulator_params * z_impl_flash_simulator_get_params(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct flash_simulator_params * flash_simulator_get_params(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (const struct flash_simulator_params *) arch_syscall_invoke1(parm0.x, K_SYSCALL_FLASH_SIMULATOR_GET_PARAMS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_simulator_get_params(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_simulator_get_params(dev) ({ const struct flash_simulator_params * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_SIMULATOR_GET_PARAMS, flash_simulator_get_params, dev); syscall__retval = flash_simulator_get_params(dev); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_SIMULATOR_GET_PARAMS, flash_simulator_get_params, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_flash_simulator_set_callbacks(const struct device * dev, const struct flash_simulator_cb * cb);
|
||||
|
||||
__pinned_func
|
||||
static inline void flash_simulator_set_callbacks(const struct device * dev, const struct flash_simulator_cb * cb)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct flash_simulator_cb * val; } parm1 = { .val = cb };
|
||||
(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_FLASH_SIMULATOR_SET_CALLBACKS);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_flash_simulator_set_callbacks(dev, cb);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_simulator_set_callbacks(dev, cb) do { sys_port_trace_syscall_enter(K_SYSCALL_FLASH_SIMULATOR_SET_CALLBACKS, flash_simulator_set_callbacks, dev, cb); flash_simulator_set_callbacks(dev, cb); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_SIMULATOR_SET_CALLBACKS, flash_simulator_set_callbacks, dev, cb); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void * z_impl_flash_simulator_get_memory(const struct device * dev, size_t * mock_size);
|
||||
|
||||
__pinned_func
|
||||
static inline void * flash_simulator_get_memory(const struct device * dev, size_t * mock_size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; size_t * val; } parm1 = { .val = mock_size };
|
||||
return (void *) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_FLASH_SIMULATOR_GET_MEMORY);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_simulator_get_memory(dev, mock_size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_simulator_get_memory(dev, mock_size) ({ void * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_SIMULATOR_GET_MEMORY, flash_simulator_get_memory, dev, mock_size); syscall__retval = flash_simulator_get_memory(dev, mock_size); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_SIMULATOR_GET_MEMORY, flash_simulator_get_memory, dev, mock_size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
179
build/zephyr/include/generated/zephyr/syscalls/fuel_gauge.h
Normal file
179
build/zephyr/include/generated/zephyr/syscalls/fuel_gauge.h
Normal file
@@ -0,0 +1,179 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_FUEL_GAUGE_H
|
||||
#define Z_INCLUDE_SYSCALLS_FUEL_GAUGE_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_fuel_gauge_get_prop(const struct device * dev, fuel_gauge_prop_t prop, union fuel_gauge_prop_val * val);
|
||||
|
||||
__pinned_func
|
||||
static inline int fuel_gauge_get_prop(const struct device * dev, fuel_gauge_prop_t prop, union fuel_gauge_prop_val * val)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; fuel_gauge_prop_t val; } parm1 = { .val = prop };
|
||||
union { uintptr_t x; union fuel_gauge_prop_val * val; } parm2 = { .val = val };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FUEL_GAUGE_GET_PROP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_fuel_gauge_get_prop(dev, prop, val);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define fuel_gauge_get_prop(dev, prop, val) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_GET_PROP, fuel_gauge_get_prop, dev, prop, val); syscall__retval = fuel_gauge_get_prop(dev, prop, val); sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_GET_PROP, fuel_gauge_get_prop, dev, prop, val, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_fuel_gauge_get_props(const struct device * dev, const fuel_gauge_prop_t * props, union fuel_gauge_prop_val * vals, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int fuel_gauge_get_props(const struct device * dev, const fuel_gauge_prop_t * props, union fuel_gauge_prop_val * vals, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const fuel_gauge_prop_t * val; } parm1 = { .val = props };
|
||||
union { uintptr_t x; union fuel_gauge_prop_val * val; } parm2 = { .val = vals };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FUEL_GAUGE_GET_PROPS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_fuel_gauge_get_props(dev, props, vals, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define fuel_gauge_get_props(dev, props, vals, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_GET_PROPS, fuel_gauge_get_props, dev, props, vals, len); syscall__retval = fuel_gauge_get_props(dev, props, vals, len); sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_GET_PROPS, fuel_gauge_get_props, dev, props, vals, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_fuel_gauge_set_prop(const struct device * dev, fuel_gauge_prop_t prop, union fuel_gauge_prop_val val);
|
||||
|
||||
__pinned_func
|
||||
static inline int fuel_gauge_set_prop(const struct device * dev, fuel_gauge_prop_t prop, union fuel_gauge_prop_val val)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; fuel_gauge_prop_t val; } parm1 = { .val = prop };
|
||||
union { uintptr_t x; union fuel_gauge_prop_val val; } parm2 = { .val = val };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FUEL_GAUGE_SET_PROP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_fuel_gauge_set_prop(dev, prop, val);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define fuel_gauge_set_prop(dev, prop, val) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_SET_PROP, fuel_gauge_set_prop, dev, prop, val); syscall__retval = fuel_gauge_set_prop(dev, prop, val); sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_SET_PROP, fuel_gauge_set_prop, dev, prop, val, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_fuel_gauge_set_props(const struct device * dev, const fuel_gauge_prop_t * props, const union fuel_gauge_prop_val * vals, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int fuel_gauge_set_props(const struct device * dev, const fuel_gauge_prop_t * props, const union fuel_gauge_prop_val * vals, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const fuel_gauge_prop_t * val; } parm1 = { .val = props };
|
||||
union { uintptr_t x; const union fuel_gauge_prop_val * val; } parm2 = { .val = vals };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FUEL_GAUGE_SET_PROPS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_fuel_gauge_set_props(dev, props, vals, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define fuel_gauge_set_props(dev, props, vals, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_SET_PROPS, fuel_gauge_set_props, dev, props, vals, len); syscall__retval = fuel_gauge_set_props(dev, props, vals, len); sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_SET_PROPS, fuel_gauge_set_props, dev, props, vals, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_fuel_gauge_get_buffer_prop(const struct device * dev, fuel_gauge_prop_t prop_type, void * dst, size_t dst_len);
|
||||
|
||||
__pinned_func
|
||||
static inline int fuel_gauge_get_buffer_prop(const struct device * dev, fuel_gauge_prop_t prop_type, void * dst, size_t dst_len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; fuel_gauge_prop_t val; } parm1 = { .val = prop_type };
|
||||
union { uintptr_t x; void * val; } parm2 = { .val = dst };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = dst_len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_fuel_gauge_get_buffer_prop(dev, prop_type, dst, dst_len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define fuel_gauge_get_buffer_prop(dev, prop_type, dst, dst_len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP, fuel_gauge_get_buffer_prop, dev, prop_type, dst, dst_len); syscall__retval = fuel_gauge_get_buffer_prop(dev, prop_type, dst, dst_len); sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP, fuel_gauge_get_buffer_prop, dev, prop_type, dst, dst_len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_fuel_gauge_battery_cutoff(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int fuel_gauge_battery_cutoff(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_fuel_gauge_battery_cutoff(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define fuel_gauge_battery_cutoff(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF, fuel_gauge_battery_cutoff, dev); syscall__retval = fuel_gauge_battery_cutoff(dev); sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF, fuel_gauge_battery_cutoff, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
220
build/zephyr/include/generated/zephyr/syscalls/gnss.h
Normal file
220
build/zephyr/include/generated/zephyr/syscalls/gnss.h
Normal file
@@ -0,0 +1,220 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_GNSS_H
|
||||
#define Z_INCLUDE_SYSCALLS_GNSS_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_gnss_set_fix_rate(const struct device * dev, uint32_t fix_interval_ms);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_set_fix_rate(const struct device * dev, uint32_t fix_interval_ms)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = fix_interval_ms };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_SET_FIX_RATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_set_fix_rate(dev, fix_interval_ms);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_set_fix_rate(dev, fix_interval_ms) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_SET_FIX_RATE, gnss_set_fix_rate, dev, fix_interval_ms); syscall__retval = gnss_set_fix_rate(dev, fix_interval_ms); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_SET_FIX_RATE, gnss_set_fix_rate, dev, fix_interval_ms, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gnss_get_fix_rate(const struct device * dev, uint32_t * fix_interval_ms);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_get_fix_rate(const struct device * dev, uint32_t * fix_interval_ms)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t * val; } parm1 = { .val = fix_interval_ms };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_FIX_RATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_get_fix_rate(dev, fix_interval_ms);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_get_fix_rate(dev, fix_interval_ms) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_FIX_RATE, gnss_get_fix_rate, dev, fix_interval_ms); syscall__retval = gnss_get_fix_rate(dev, fix_interval_ms); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_FIX_RATE, gnss_get_fix_rate, dev, fix_interval_ms, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gnss_set_navigation_mode(const struct device * dev, enum gnss_navigation_mode mode);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_set_navigation_mode(const struct device * dev, enum gnss_navigation_mode mode)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum gnss_navigation_mode val; } parm1 = { .val = mode };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_SET_NAVIGATION_MODE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_set_navigation_mode(dev, mode);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_set_navigation_mode(dev, mode) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_SET_NAVIGATION_MODE, gnss_set_navigation_mode, dev, mode); syscall__retval = gnss_set_navigation_mode(dev, mode); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_SET_NAVIGATION_MODE, gnss_set_navigation_mode, dev, mode, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gnss_get_navigation_mode(const struct device * dev, enum gnss_navigation_mode * mode);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_get_navigation_mode(const struct device * dev, enum gnss_navigation_mode * mode)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum gnss_navigation_mode * val; } parm1 = { .val = mode };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_NAVIGATION_MODE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_get_navigation_mode(dev, mode);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_get_navigation_mode(dev, mode) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_NAVIGATION_MODE, gnss_get_navigation_mode, dev, mode); syscall__retval = gnss_get_navigation_mode(dev, mode); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_NAVIGATION_MODE, gnss_get_navigation_mode, dev, mode, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gnss_set_enabled_systems(const struct device * dev, gnss_systems_t systems);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_set_enabled_systems(const struct device * dev, gnss_systems_t systems)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; gnss_systems_t val; } parm1 = { .val = systems };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_set_enabled_systems(dev, systems);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_set_enabled_systems(dev, systems) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS, gnss_set_enabled_systems, dev, systems); syscall__retval = gnss_set_enabled_systems(dev, systems); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS, gnss_set_enabled_systems, dev, systems, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gnss_get_enabled_systems(const struct device * dev, gnss_systems_t * systems);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_get_enabled_systems(const struct device * dev, gnss_systems_t * systems)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; gnss_systems_t * val; } parm1 = { .val = systems };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_get_enabled_systems(dev, systems);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_get_enabled_systems(dev, systems) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS, gnss_get_enabled_systems, dev, systems); syscall__retval = gnss_get_enabled_systems(dev, systems); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS, gnss_get_enabled_systems, dev, systems, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gnss_get_supported_systems(const struct device * dev, gnss_systems_t * systems);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_get_supported_systems(const struct device * dev, gnss_systems_t * systems)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; gnss_systems_t * val; } parm1 = { .val = systems };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_get_supported_systems(dev, systems);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_get_supported_systems(dev, systems) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS, gnss_get_supported_systems, dev, systems); syscall__retval = gnss_get_supported_systems(dev, systems); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS, gnss_get_supported_systems, dev, systems, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gnss_get_latest_timepulse(const struct device * dev, k_ticks_t * timestamp);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_get_latest_timepulse(const struct device * dev, k_ticks_t * timestamp)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; k_ticks_t * val; } parm1 = { .val = timestamp };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_LATEST_TIMEPULSE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_get_latest_timepulse(dev, timestamp);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_get_latest_timepulse(dev, timestamp) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_LATEST_TIMEPULSE, gnss_get_latest_timepulse, dev, timestamp); syscall__retval = gnss_get_latest_timepulse(dev, timestamp); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_LATEST_TIMEPULSE, gnss_get_latest_timepulse, dev, timestamp, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
273
build/zephyr/include/generated/zephyr/syscalls/gpio.h
Normal file
273
build/zephyr/include/generated/zephyr/syscalls/gpio.h
Normal file
@@ -0,0 +1,273 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_GPIO_H
|
||||
#define Z_INCLUDE_SYSCALLS_GPIO_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_gpio_pin_interrupt_configure(const struct device * port, gpio_pin_t pin, gpio_flags_t flags);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_pin_interrupt_configure(const struct device * port, gpio_pin_t pin, gpio_flags_t flags)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_pin_t val; } parm1 = { .val = pin };
|
||||
union { uintptr_t x; gpio_flags_t val; } parm2 = { .val = flags };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_pin_interrupt_configure(port, pin, flags);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_pin_interrupt_configure(port, pin, flags) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE, gpio_pin_interrupt_configure, port, pin, flags); syscall__retval = gpio_pin_interrupt_configure(port, pin, flags); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE, gpio_pin_interrupt_configure, port, pin, flags, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_pin_configure(const struct device * port, gpio_pin_t pin, gpio_flags_t flags);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_pin_configure(const struct device * port, gpio_pin_t pin, gpio_flags_t flags)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_pin_t val; } parm1 = { .val = pin };
|
||||
union { uintptr_t x; gpio_flags_t val; } parm2 = { .val = flags };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_GPIO_PIN_CONFIGURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_pin_configure(port, pin, flags);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_pin_configure(port, pin, flags) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PIN_CONFIGURE, gpio_pin_configure, port, pin, flags); syscall__retval = gpio_pin_configure(port, pin, flags); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PIN_CONFIGURE, gpio_pin_configure, port, pin, flags, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_port_get_direction(const struct device * port, gpio_port_pins_t map, gpio_port_pins_t * inputs, gpio_port_pins_t * outputs);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_port_get_direction(const struct device * port, gpio_port_pins_t map, gpio_port_pins_t * inputs, gpio_port_pins_t * outputs)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = map };
|
||||
union { uintptr_t x; gpio_port_pins_t * val; } parm2 = { .val = inputs };
|
||||
union { uintptr_t x; gpio_port_pins_t * val; } parm3 = { .val = outputs };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_GPIO_PORT_GET_DIRECTION);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_port_get_direction(port, map, inputs, outputs);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_port_get_direction(port, map, inputs, outputs) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_GET_DIRECTION, gpio_port_get_direction, port, map, inputs, outputs); syscall__retval = gpio_port_get_direction(port, map, inputs, outputs); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_GET_DIRECTION, gpio_port_get_direction, port, map, inputs, outputs, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_pin_get_config(const struct device * port, gpio_pin_t pin, gpio_flags_t * flags);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_pin_get_config(const struct device * port, gpio_pin_t pin, gpio_flags_t * flags)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_pin_t val; } parm1 = { .val = pin };
|
||||
union { uintptr_t x; gpio_flags_t * val; } parm2 = { .val = flags };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_GPIO_PIN_GET_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_pin_get_config(port, pin, flags);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_pin_get_config(port, pin, flags) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PIN_GET_CONFIG, gpio_pin_get_config, port, pin, flags); syscall__retval = gpio_pin_get_config(port, pin, flags); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PIN_GET_CONFIG, gpio_pin_get_config, port, pin, flags, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_port_get_raw(const struct device * port, gpio_port_value_t * value);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_port_get_raw(const struct device * port, gpio_port_value_t * value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_port_value_t * val; } parm1 = { .val = value };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GPIO_PORT_GET_RAW);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_port_get_raw(port, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_port_get_raw(port, value) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_GET_RAW, gpio_port_get_raw, port, value); syscall__retval = gpio_port_get_raw(port, value); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_GET_RAW, gpio_port_get_raw, port, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_port_set_masked_raw(const struct device * port, gpio_port_pins_t mask, gpio_port_value_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_port_set_masked_raw(const struct device * port, gpio_port_pins_t mask, gpio_port_value_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = mask };
|
||||
union { uintptr_t x; gpio_port_value_t val; } parm2 = { .val = value };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_GPIO_PORT_SET_MASKED_RAW);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_port_set_masked_raw(port, mask, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_port_set_masked_raw(port, mask, value) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_SET_MASKED_RAW, gpio_port_set_masked_raw, port, mask, value); syscall__retval = gpio_port_set_masked_raw(port, mask, value); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_SET_MASKED_RAW, gpio_port_set_masked_raw, port, mask, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_port_set_bits_raw(const struct device * port, gpio_port_pins_t pins);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_port_set_bits_raw(const struct device * port, gpio_port_pins_t pins)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = pins };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GPIO_PORT_SET_BITS_RAW);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_port_set_bits_raw(port, pins);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_port_set_bits_raw(port, pins) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_SET_BITS_RAW, gpio_port_set_bits_raw, port, pins); syscall__retval = gpio_port_set_bits_raw(port, pins); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_SET_BITS_RAW, gpio_port_set_bits_raw, port, pins, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_port_clear_bits_raw(const struct device * port, gpio_port_pins_t pins);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_port_clear_bits_raw(const struct device * port, gpio_port_pins_t pins)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = pins };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_port_clear_bits_raw(port, pins);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_port_clear_bits_raw(port, pins) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW, gpio_port_clear_bits_raw, port, pins); syscall__retval = gpio_port_clear_bits_raw(port, pins); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW, gpio_port_clear_bits_raw, port, pins, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_port_toggle_bits(const struct device * port, gpio_port_pins_t pins);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_port_toggle_bits(const struct device * port, gpio_port_pins_t pins)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = pins };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GPIO_PORT_TOGGLE_BITS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_port_toggle_bits(port, pins);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_port_toggle_bits(port, pins) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_TOGGLE_BITS, gpio_port_toggle_bits, port, pins); syscall__retval = gpio_port_toggle_bits(port, pins); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_TOGGLE_BITS, gpio_port_toggle_bits, port, pins, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_get_pending_int(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_get_pending_int(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_GPIO_GET_PENDING_INT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_get_pending_int(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_get_pending_int(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_GET_PENDING_INT, gpio_get_pending_int, dev); syscall__retval = gpio_get_pending_int(dev); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_GET_PENDING_INT, gpio_get_pending_int, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
74
build/zephyr/include/generated/zephyr/syscalls/haptics.h
Normal file
74
build/zephyr/include/generated/zephyr/syscalls/haptics.h
Normal file
@@ -0,0 +1,74 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_HAPTICS_H
|
||||
#define Z_INCLUDE_SYSCALLS_HAPTICS_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_haptics_start_output(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int haptics_start_output(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_HAPTICS_START_OUTPUT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_haptics_start_output(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define haptics_start_output(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_HAPTICS_START_OUTPUT, haptics_start_output, dev); syscall__retval = haptics_start_output(dev); sys_port_trace_syscall_exit(K_SYSCALL_HAPTICS_START_OUTPUT, haptics_start_output, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_haptics_stop_output(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int haptics_stop_output(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_HAPTICS_STOP_OUTPUT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_haptics_stop_output(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define haptics_stop_output(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_HAPTICS_STOP_OUTPUT, haptics_stop_output, dev); syscall__retval = haptics_stop_output(dev); sys_port_trace_syscall_exit(K_SYSCALL_HAPTICS_STOP_OUTPUT, haptics_stop_output, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
143
build/zephyr/include/generated/zephyr/syscalls/hwinfo.h
Normal file
143
build/zephyr/include/generated/zephyr/syscalls/hwinfo.h
Normal file
@@ -0,0 +1,143 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_HWINFO_H
|
||||
#define Z_INCLUDE_SYSCALLS_HWINFO_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern ssize_t z_impl_hwinfo_get_device_id(uint8_t * buffer, size_t length);
|
||||
|
||||
__pinned_func
|
||||
static inline ssize_t hwinfo_get_device_id(uint8_t * buffer, size_t length)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; uint8_t * val; } parm0 = { .val = buffer };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = length };
|
||||
return (ssize_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_HWINFO_GET_DEVICE_ID);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_hwinfo_get_device_id(buffer, length);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define hwinfo_get_device_id(buffer, length) ({ ssize_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_GET_DEVICE_ID, hwinfo_get_device_id, buffer, length); syscall__retval = hwinfo_get_device_id(buffer, length); sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_GET_DEVICE_ID, hwinfo_get_device_id, buffer, length, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_hwinfo_get_device_eui64(uint8_t * buffer);
|
||||
|
||||
__pinned_func
|
||||
static inline int hwinfo_get_device_eui64(uint8_t * buffer)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; uint8_t * val; } parm0 = { .val = buffer };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_HWINFO_GET_DEVICE_EUI64);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_hwinfo_get_device_eui64(buffer);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define hwinfo_get_device_eui64(buffer) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_GET_DEVICE_EUI64, hwinfo_get_device_eui64, buffer); syscall__retval = hwinfo_get_device_eui64(buffer); sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_GET_DEVICE_EUI64, hwinfo_get_device_eui64, buffer, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_hwinfo_get_reset_cause(uint32_t * cause);
|
||||
|
||||
__pinned_func
|
||||
static inline int hwinfo_get_reset_cause(uint32_t * cause)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; uint32_t * val; } parm0 = { .val = cause };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_HWINFO_GET_RESET_CAUSE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_hwinfo_get_reset_cause(cause);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define hwinfo_get_reset_cause(cause) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_GET_RESET_CAUSE, hwinfo_get_reset_cause, cause); syscall__retval = hwinfo_get_reset_cause(cause); sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_GET_RESET_CAUSE, hwinfo_get_reset_cause, cause, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_hwinfo_clear_reset_cause(void);
|
||||
|
||||
__pinned_func
|
||||
static inline int hwinfo_clear_reset_cause(void)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
return (int) arch_syscall_invoke0(K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_hwinfo_clear_reset_cause();
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define hwinfo_clear_reset_cause() ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE, hwinfo_clear_reset_cause); syscall__retval = hwinfo_clear_reset_cause(); sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE, hwinfo_clear_reset_cause, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_hwinfo_get_supported_reset_cause(uint32_t * supported);
|
||||
|
||||
__pinned_func
|
||||
static inline int hwinfo_get_supported_reset_cause(uint32_t * supported)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; uint32_t * val; } parm0 = { .val = supported };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_hwinfo_get_supported_reset_cause(supported);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define hwinfo_get_supported_reset_cause(supported) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE, hwinfo_get_supported_reset_cause, supported); syscall__retval = hwinfo_get_supported_reset_cause(supported); sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE, hwinfo_get_supported_reset_cause, supported, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
171
build/zephyr/include/generated/zephyr/syscalls/i2c.h
Normal file
171
build/zephyr/include/generated/zephyr/syscalls/i2c.h
Normal file
@@ -0,0 +1,171 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_I2C_H
|
||||
#define Z_INCLUDE_SYSCALLS_I2C_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_i2c_configure(const struct device * dev, uint32_t dev_config);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2c_configure(const struct device * dev, uint32_t dev_config)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = dev_config };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_I2C_CONFIGURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2c_configure(dev, dev_config);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2c_configure(dev, dev_config) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2C_CONFIGURE, i2c_configure, dev, dev_config); syscall__retval = i2c_configure(dev, dev_config); sys_port_trace_syscall_exit(K_SYSCALL_I2C_CONFIGURE, i2c_configure, dev, dev_config, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2c_get_config(const struct device * dev, uint32_t * dev_config);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2c_get_config(const struct device * dev, uint32_t * dev_config)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t * val; } parm1 = { .val = dev_config };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_I2C_GET_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2c_get_config(dev, dev_config);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2c_get_config(dev, dev_config) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2C_GET_CONFIG, i2c_get_config, dev, dev_config); syscall__retval = i2c_get_config(dev, dev_config); sys_port_trace_syscall_exit(K_SYSCALL_I2C_GET_CONFIG, i2c_get_config, dev, dev_config, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2c_transfer(const struct device * dev, struct i2c_msg * msgs, uint8_t num_msgs, uint16_t addr);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2c_transfer(const struct device * dev, struct i2c_msg * msgs, uint8_t num_msgs, uint16_t addr)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct i2c_msg * val; } parm1 = { .val = msgs };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = num_msgs };
|
||||
union { uintptr_t x; uint16_t val; } parm3 = { .val = addr };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_I2C_TRANSFER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2c_transfer(dev, msgs, num_msgs, addr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2c_transfer(dev, msgs, num_msgs, addr) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2C_TRANSFER, i2c_transfer, dev, msgs, num_msgs, addr); syscall__retval = i2c_transfer(dev, msgs, num_msgs, addr); sys_port_trace_syscall_exit(K_SYSCALL_I2C_TRANSFER, i2c_transfer, dev, msgs, num_msgs, addr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2c_recover_bus(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2c_recover_bus(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_I2C_RECOVER_BUS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2c_recover_bus(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2c_recover_bus(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2C_RECOVER_BUS, i2c_recover_bus, dev); syscall__retval = i2c_recover_bus(dev); sys_port_trace_syscall_exit(K_SYSCALL_I2C_RECOVER_BUS, i2c_recover_bus, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2c_target_driver_register(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2c_target_driver_register(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_I2C_TARGET_DRIVER_REGISTER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2c_target_driver_register(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2c_target_driver_register(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2C_TARGET_DRIVER_REGISTER, i2c_target_driver_register, dev); syscall__retval = i2c_target_driver_register(dev); sys_port_trace_syscall_exit(K_SYSCALL_I2C_TARGET_DRIVER_REGISTER, i2c_target_driver_register, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2c_target_driver_unregister(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2c_target_driver_unregister(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2c_target_driver_unregister(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2c_target_driver_unregister(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER, i2c_target_driver_unregister, dev); syscall__retval = i2c_target_driver_unregister(dev); sys_port_trace_syscall_exit(K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER, i2c_target_driver_unregister, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
128
build/zephyr/include/generated/zephyr/syscalls/i2s.h
Normal file
128
build/zephyr/include/generated/zephyr/syscalls/i2s.h
Normal file
@@ -0,0 +1,128 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_I2S_H
|
||||
#define Z_INCLUDE_SYSCALLS_I2S_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_i2s_configure(const struct device * dev, enum i2s_dir dir, const struct i2s_config * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2s_configure(const struct device * dev, enum i2s_dir dir, const struct i2s_config * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum i2s_dir val; } parm1 = { .val = dir };
|
||||
union { uintptr_t x; const struct i2s_config * val; } parm2 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I2S_CONFIGURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2s_configure(dev, dir, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2s_configure(dev, dir, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2S_CONFIGURE, i2s_configure, dev, dir, cfg); syscall__retval = i2s_configure(dev, dir, cfg); sys_port_trace_syscall_exit(K_SYSCALL_I2S_CONFIGURE, i2s_configure, dev, dir, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2s_buf_read(const struct device * dev, void * buf, size_t * size);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2s_buf_read(const struct device * dev, void * buf, size_t * size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; void * val; } parm1 = { .val = buf };
|
||||
union { uintptr_t x; size_t * val; } parm2 = { .val = size };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I2S_BUF_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2s_buf_read(dev, buf, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2s_buf_read(dev, buf, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2S_BUF_READ, i2s_buf_read, dev, buf, size); syscall__retval = i2s_buf_read(dev, buf, size); sys_port_trace_syscall_exit(K_SYSCALL_I2S_BUF_READ, i2s_buf_read, dev, buf, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2s_buf_write(const struct device * dev, void * buf, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2s_buf_write(const struct device * dev, void * buf, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; void * val; } parm1 = { .val = buf };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = size };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I2S_BUF_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2s_buf_write(dev, buf, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2s_buf_write(dev, buf, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2S_BUF_WRITE, i2s_buf_write, dev, buf, size); syscall__retval = i2s_buf_write(dev, buf, size); sys_port_trace_syscall_exit(K_SYSCALL_I2S_BUF_WRITE, i2s_buf_write, dev, buf, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2s_trigger(const struct device * dev, enum i2s_dir dir, enum i2s_trigger_cmd cmd);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2s_trigger(const struct device * dev, enum i2s_dir dir, enum i2s_trigger_cmd cmd)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum i2s_dir val; } parm1 = { .val = dir };
|
||||
union { uintptr_t x; enum i2s_trigger_cmd val; } parm2 = { .val = cmd };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I2S_TRIGGER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2s_trigger(dev, dir, cmd);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2s_trigger(dev, dir, cmd) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2S_TRIGGER, i2s_trigger, dev, dir, cmd); syscall__retval = i2s_trigger(dev, dir, cmd); sys_port_trace_syscall_exit(K_SYSCALL_I2S_TRIGGER, i2s_trigger, dev, dir, cmd, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
77
build/zephyr/include/generated/zephyr/syscalls/i3c.h
Normal file
77
build/zephyr/include/generated/zephyr/syscalls/i3c.h
Normal file
@@ -0,0 +1,77 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_I3C_H
|
||||
#define Z_INCLUDE_SYSCALLS_I3C_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_i3c_do_ccc(const struct device * dev, struct i3c_ccc_payload * payload);
|
||||
|
||||
__pinned_func
|
||||
static inline int i3c_do_ccc(const struct device * dev, struct i3c_ccc_payload * payload)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct i3c_ccc_payload * val; } parm1 = { .val = payload };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_I3C_DO_CCC);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i3c_do_ccc(dev, payload);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i3c_do_ccc(dev, payload) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I3C_DO_CCC, i3c_do_ccc, dev, payload); syscall__retval = i3c_do_ccc(dev, payload); sys_port_trace_syscall_exit(K_SYSCALL_I3C_DO_CCC, i3c_do_ccc, dev, payload, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i3c_transfer(struct i3c_device_desc * target, struct i3c_msg * msgs, uint8_t num_msgs);
|
||||
|
||||
__pinned_func
|
||||
static inline int i3c_transfer(struct i3c_device_desc * target, struct i3c_msg * msgs, uint8_t num_msgs)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct i3c_device_desc * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; struct i3c_msg * val; } parm1 = { .val = msgs };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = num_msgs };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I3C_TRANSFER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i3c_transfer(target, msgs, num_msgs);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i3c_transfer(target, msgs, num_msgs) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I3C_TRANSFER, i3c_transfer, target, msgs, num_msgs); syscall__retval = i3c_transfer(target, msgs, num_msgs); sys_port_trace_syscall_exit(K_SYSCALL_I3C_TRANSFER, i3c_transfer, target, msgs, num_msgs, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,52 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_INPUT_RENESAS_RA_CTSU_H
|
||||
#define Z_INCLUDE_SYSCALLS_INPUT_RENESAS_RA_CTSU_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_renesas_ra_ctsu_group_configure(const struct device * dev, const struct renesas_ra_ctsu_touch_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int renesas_ra_ctsu_group_configure(const struct device * dev, const struct renesas_ra_ctsu_touch_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct renesas_ra_ctsu_touch_cfg * val; } parm1 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RENESAS_RA_CTSU_GROUP_CONFIGURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_renesas_ra_ctsu_group_configure(dev, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define renesas_ra_ctsu_group_configure(dev, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RENESAS_RA_CTSU_GROUP_CONFIGURE, renesas_ra_ctsu_group_configure, dev, cfg); syscall__retval = renesas_ra_ctsu_group_configure(dev, cfg); sys_port_trace_syscall_exit(K_SYSCALL_RENESAS_RA_CTSU_GROUP_CONFIGURE, renesas_ra_ctsu_group_configure, dev, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,52 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_INPUT_RENESAS_RX_CTSU_H
|
||||
#define Z_INCLUDE_SYSCALLS_INPUT_RENESAS_RX_CTSU_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_renesas_rx_ctsu_group_configure(const struct device * dev, const struct renesas_rx_ctsu_touch_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int renesas_rx_ctsu_group_configure(const struct device * dev, const struct renesas_rx_ctsu_touch_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct renesas_rx_ctsu_touch_cfg * val; } parm1 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RENESAS_RX_CTSU_GROUP_CONFIGURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_renesas_rx_ctsu_group_configure(dev, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define renesas_rx_ctsu_group_configure(dev, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RENESAS_RX_CTSU_GROUP_CONFIGURE, renesas_rx_ctsu_group_configure, dev, cfg); syscall__retval = renesas_rx_ctsu_group_configure(dev, cfg); sys_port_trace_syscall_exit(K_SYSCALL_RENESAS_RX_CTSU_GROUP_CONFIGURE, renesas_rx_ctsu_group_configure, dev, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
149
build/zephyr/include/generated/zephyr/syscalls/ipm.h
Normal file
149
build/zephyr/include/generated/zephyr/syscalls/ipm.h
Normal file
@@ -0,0 +1,149 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_IPM_H
|
||||
#define Z_INCLUDE_SYSCALLS_IPM_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_ipm_send(const struct device * ipmdev, int wait, uint32_t id, const void * data, int size);
|
||||
|
||||
__pinned_func
|
||||
static inline int ipm_send(const struct device * ipmdev, int wait, uint32_t id, const void * data, int size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
|
||||
union { uintptr_t x; int val; } parm1 = { .val = wait };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = id };
|
||||
union { uintptr_t x; const void * val; } parm3 = { .val = data };
|
||||
union { uintptr_t x; int val; } parm4 = { .val = size };
|
||||
return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_IPM_SEND);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ipm_send(ipmdev, wait, id, data, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ipm_send(ipmdev, wait, id, data, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IPM_SEND, ipm_send, ipmdev, wait, id, data, size); syscall__retval = ipm_send(ipmdev, wait, id, data, size); sys_port_trace_syscall_exit(K_SYSCALL_IPM_SEND, ipm_send, ipmdev, wait, id, data, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ipm_max_data_size_get(const struct device * ipmdev);
|
||||
|
||||
__pinned_func
|
||||
static inline int ipm_max_data_size_get(const struct device * ipmdev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_IPM_MAX_DATA_SIZE_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ipm_max_data_size_get(ipmdev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ipm_max_data_size_get(ipmdev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IPM_MAX_DATA_SIZE_GET, ipm_max_data_size_get, ipmdev); syscall__retval = ipm_max_data_size_get(ipmdev); sys_port_trace_syscall_exit(K_SYSCALL_IPM_MAX_DATA_SIZE_GET, ipm_max_data_size_get, ipmdev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_ipm_max_id_val_get(const struct device * ipmdev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t ipm_max_id_val_get(const struct device * ipmdev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IPM_MAX_ID_VAL_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ipm_max_id_val_get(ipmdev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ipm_max_id_val_get(ipmdev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IPM_MAX_ID_VAL_GET, ipm_max_id_val_get, ipmdev); syscall__retval = ipm_max_id_val_get(ipmdev); sys_port_trace_syscall_exit(K_SYSCALL_IPM_MAX_ID_VAL_GET, ipm_max_id_val_get, ipmdev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ipm_set_enabled(const struct device * ipmdev, int enable);
|
||||
|
||||
__pinned_func
|
||||
static inline int ipm_set_enabled(const struct device * ipmdev, int enable)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
|
||||
union { uintptr_t x; int val; } parm1 = { .val = enable };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IPM_SET_ENABLED);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ipm_set_enabled(ipmdev, enable);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ipm_set_enabled(ipmdev, enable) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IPM_SET_ENABLED, ipm_set_enabled, ipmdev, enable); syscall__retval = ipm_set_enabled(ipmdev, enable); sys_port_trace_syscall_exit(K_SYSCALL_IPM_SET_ENABLED, ipm_set_enabled, ipmdev, enable, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_ipm_complete(const struct device * ipmdev);
|
||||
|
||||
__pinned_func
|
||||
static inline void ipm_complete(const struct device * ipmdev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_IPM_COMPLETE);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_ipm_complete(ipmdev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ipm_complete(ipmdev) do { sys_port_trace_syscall_enter(K_SYSCALL_IPM_COMPLETE, ipm_complete, ipmdev); ipm_complete(ipmdev); sys_port_trace_syscall_exit(K_SYSCALL_IPM_COMPLETE, ipm_complete, ipmdev); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
315
build/zephyr/include/generated/zephyr/syscalls/ivshmem.h
Normal file
315
build/zephyr/include/generated/zephyr/syscalls/ivshmem.h
Normal file
@@ -0,0 +1,315 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_IVSHMEM_H
|
||||
#define Z_INCLUDE_SYSCALLS_IVSHMEM_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern size_t z_impl_ivshmem_get_mem(const struct device * dev, uintptr_t * memmap);
|
||||
|
||||
__pinned_func
|
||||
static inline size_t ivshmem_get_mem(const struct device * dev, uintptr_t * memmap)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uintptr_t * val; } parm1 = { .val = memmap };
|
||||
return (size_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_GET_MEM);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_mem(dev, memmap);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_mem(dev, memmap) ({ size_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_MEM, ivshmem_get_mem, dev, memmap); syscall__retval = ivshmem_get_mem(dev, memmap); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_MEM, ivshmem_get_mem, dev, memmap, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_ivshmem_get_id(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t ivshmem_get_id(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IVSHMEM_GET_ID);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_id(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_id(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_ID, ivshmem_get_id, dev); syscall__retval = ivshmem_get_id(dev); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_ID, ivshmem_get_id, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint16_t z_impl_ivshmem_get_vectors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint16_t ivshmem_get_vectors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint16_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IVSHMEM_GET_VECTORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_vectors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_vectors(dev) ({ uint16_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_VECTORS, ivshmem_get_vectors, dev); syscall__retval = ivshmem_get_vectors(dev); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_VECTORS, ivshmem_get_vectors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ivshmem_int_peer(const struct device * dev, uint32_t peer_id, uint16_t vector);
|
||||
|
||||
__pinned_func
|
||||
static inline int ivshmem_int_peer(const struct device * dev, uint32_t peer_id, uint16_t vector)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = peer_id };
|
||||
union { uintptr_t x; uint16_t val; } parm2 = { .val = vector };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_IVSHMEM_INT_PEER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_int_peer(dev, peer_id, vector);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_int_peer(dev, peer_id, vector) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_INT_PEER, ivshmem_int_peer, dev, peer_id, vector); syscall__retval = ivshmem_int_peer(dev, peer_id, vector); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_INT_PEER, ivshmem_int_peer, dev, peer_id, vector, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ivshmem_register_handler(const struct device * dev, struct k_poll_signal * signal, uint16_t vector);
|
||||
|
||||
__pinned_func
|
||||
static inline int ivshmem_register_handler(const struct device * dev, struct k_poll_signal * signal, uint16_t vector)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct k_poll_signal * val; } parm1 = { .val = signal };
|
||||
union { uintptr_t x; uint16_t val; } parm2 = { .val = vector };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_IVSHMEM_REGISTER_HANDLER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_register_handler(dev, signal, vector);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_register_handler(dev, signal, vector) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_REGISTER_HANDLER, ivshmem_register_handler, dev, signal, vector); syscall__retval = ivshmem_register_handler(dev, signal, vector); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_REGISTER_HANDLER, ivshmem_register_handler, dev, signal, vector, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern size_t z_impl_ivshmem_get_rw_mem_section(const struct device * dev, uintptr_t * memmap);
|
||||
|
||||
__pinned_func
|
||||
static inline size_t ivshmem_get_rw_mem_section(const struct device * dev, uintptr_t * memmap)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uintptr_t * val; } parm1 = { .val = memmap };
|
||||
return (size_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_rw_mem_section(dev, memmap);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_rw_mem_section(dev, memmap) ({ size_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION, ivshmem_get_rw_mem_section, dev, memmap); syscall__retval = ivshmem_get_rw_mem_section(dev, memmap); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION, ivshmem_get_rw_mem_section, dev, memmap, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern size_t z_impl_ivshmem_get_output_mem_section(const struct device * dev, uint32_t peer_id, uintptr_t * memmap);
|
||||
|
||||
__pinned_func
|
||||
static inline size_t ivshmem_get_output_mem_section(const struct device * dev, uint32_t peer_id, uintptr_t * memmap)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = peer_id };
|
||||
union { uintptr_t x; uintptr_t * val; } parm2 = { .val = memmap };
|
||||
return (size_t) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_output_mem_section(dev, peer_id, memmap);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_output_mem_section(dev, peer_id, memmap) ({ size_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION, ivshmem_get_output_mem_section, dev, peer_id, memmap); syscall__retval = ivshmem_get_output_mem_section(dev, peer_id, memmap); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION, ivshmem_get_output_mem_section, dev, peer_id, memmap, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_ivshmem_get_state(const struct device * dev, uint32_t peer_id);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t ivshmem_get_state(const struct device * dev, uint32_t peer_id)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = peer_id };
|
||||
return (uint32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_GET_STATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_state(dev, peer_id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_state(dev, peer_id) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_STATE, ivshmem_get_state, dev, peer_id); syscall__retval = ivshmem_get_state(dev, peer_id); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_STATE, ivshmem_get_state, dev, peer_id, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ivshmem_set_state(const struct device * dev, uint32_t state);
|
||||
|
||||
__pinned_func
|
||||
static inline int ivshmem_set_state(const struct device * dev, uint32_t state)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = state };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_SET_STATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_set_state(dev, state);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_set_state(dev, state) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_SET_STATE, ivshmem_set_state, dev, state); syscall__retval = ivshmem_set_state(dev, state); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_SET_STATE, ivshmem_set_state, dev, state, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_ivshmem_get_max_peers(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t ivshmem_get_max_peers(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IVSHMEM_GET_MAX_PEERS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_max_peers(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_max_peers(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_MAX_PEERS, ivshmem_get_max_peers, dev); syscall__retval = ivshmem_get_max_peers(dev); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_MAX_PEERS, ivshmem_get_max_peers, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint16_t z_impl_ivshmem_get_protocol(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint16_t ivshmem_get_protocol(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint16_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IVSHMEM_GET_PROTOCOL);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_protocol(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_protocol(dev) ({ uint16_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_PROTOCOL, ivshmem_get_protocol, dev); syscall__retval = ivshmem_get_protocol(dev); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_PROTOCOL, ivshmem_get_protocol, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ivshmem_enable_interrupts(const struct device * dev, bool enable);
|
||||
|
||||
__pinned_func
|
||||
static inline int ivshmem_enable_interrupts(const struct device * dev, bool enable)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; bool val; } parm1 = { .val = enable };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_enable_interrupts(dev, enable);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_enable_interrupts(dev, enable) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS, ivshmem_enable_interrupts, dev, enable); syscall__retval = ivshmem_enable_interrupts(dev, enable); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS, ivshmem_enable_interrupts, dev, enable, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
1670
build/zephyr/include/generated/zephyr/syscalls/kernel.h
Normal file
1670
build/zephyr/include/generated/zephyr/syscalls/kernel.h
Normal file
File diff suppressed because it is too large
Load Diff
147
build/zephyr/include/generated/zephyr/syscalls/kobject.h
Normal file
147
build/zephyr/include/generated/zephyr/syscalls/kobject.h
Normal file
@@ -0,0 +1,147 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_KOBJECT_H
|
||||
#define Z_INCLUDE_SYSCALLS_KOBJECT_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_k_object_access_grant(const void * object, struct k_thread * thread);
|
||||
|
||||
__pinned_func
|
||||
static inline void k_object_access_grant(const void * object, struct k_thread * thread)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void * val; } parm0 = { .val = object };
|
||||
union { uintptr_t x; struct k_thread * val; } parm1 = { .val = thread };
|
||||
(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_OBJECT_ACCESS_GRANT);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_k_object_access_grant(object, thread);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_object_access_grant(object, thread) do { sys_port_trace_syscall_enter(K_SYSCALL_K_OBJECT_ACCESS_GRANT, k_object_access_grant, object, thread); k_object_access_grant(object, thread); sys_port_trace_syscall_exit(K_SYSCALL_K_OBJECT_ACCESS_GRANT, k_object_access_grant, object, thread); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_k_object_release(const void * object);
|
||||
|
||||
__pinned_func
|
||||
static inline void k_object_release(const void * object)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void * val; } parm0 = { .val = object };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_OBJECT_RELEASE);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_k_object_release(object);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_object_release(object) do { sys_port_trace_syscall_enter(K_SYSCALL_K_OBJECT_RELEASE, k_object_release, object); k_object_release(object); sys_port_trace_syscall_exit(K_SYSCALL_K_OBJECT_RELEASE, k_object_release, object); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_k_object_access_check(const void * object);
|
||||
|
||||
__pinned_func
|
||||
static inline int k_object_access_check(const void * object)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void * val; } parm0 = { .val = object };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_OBJECT_ACCESS_CHECK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_k_object_access_check(object);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_object_access_check(object) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_K_OBJECT_ACCESS_CHECK, k_object_access_check, object); syscall__retval = k_object_access_check(object); sys_port_trace_syscall_exit(K_SYSCALL_K_OBJECT_ACCESS_CHECK, k_object_access_check, object, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void * z_impl_k_object_alloc(enum k_objects otype);
|
||||
|
||||
__pinned_func
|
||||
static inline void * k_object_alloc(enum k_objects otype)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; enum k_objects val; } parm0 = { .val = otype };
|
||||
return (void *) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_OBJECT_ALLOC);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_k_object_alloc(otype);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_object_alloc(otype) ({ void * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_K_OBJECT_ALLOC, k_object_alloc, otype); syscall__retval = k_object_alloc(otype); sys_port_trace_syscall_exit(K_SYSCALL_K_OBJECT_ALLOC, k_object_alloc, otype, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void * z_impl_k_object_alloc_size(enum k_objects otype, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline void * k_object_alloc_size(enum k_objects otype, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; enum k_objects val; } parm0 = { .val = otype };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = size };
|
||||
return (void *) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_OBJECT_ALLOC_SIZE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_k_object_alloc_size(otype, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_object_alloc_size(otype, size) ({ void * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_K_OBJECT_ALLOC_SIZE, k_object_alloc_size, otype, size); syscall__retval = k_object_alloc_size(otype, size); sys_port_trace_syscall_exit(K_SYSCALL_K_OBJECT_ALLOC_SIZE, k_object_alloc_size, otype, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
229
build/zephyr/include/generated/zephyr/syscalls/led.h
Normal file
229
build/zephyr/include/generated/zephyr/syscalls/led.h
Normal file
@@ -0,0 +1,229 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_LED_H
|
||||
#define Z_INCLUDE_SYSCALLS_LED_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_led_blink(const struct device * dev, uint32_t led, uint32_t delay_on, uint32_t delay_off);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_blink(const struct device * dev, uint32_t led, uint32_t delay_on, uint32_t delay_off)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = delay_on };
|
||||
union { uintptr_t x; uint32_t val; } parm3 = { .val = delay_off };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_LED_BLINK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_blink(dev, led, delay_on, delay_off);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_blink(dev, led, delay_on, delay_off) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_BLINK, led_blink, dev, led, delay_on, delay_off); syscall__retval = led_blink(dev, led, delay_on, delay_off); sys_port_trace_syscall_exit(K_SYSCALL_LED_BLINK, led_blink, dev, led, delay_on, delay_off, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_led_get_info(const struct device * dev, uint32_t led, const struct led_info ** info);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_get_info(const struct device * dev, uint32_t led, const struct led_info ** info)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
|
||||
union { uintptr_t x; const struct led_info ** val; } parm2 = { .val = info };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_LED_GET_INFO);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_get_info(dev, led, info);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_get_info(dev, led, info) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_GET_INFO, led_get_info, dev, led, info); syscall__retval = led_get_info(dev, led, info); sys_port_trace_syscall_exit(K_SYSCALL_LED_GET_INFO, led_get_info, dev, led, info, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_led_set_brightness(const struct device * dev, uint32_t led, uint8_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_set_brightness(const struct device * dev, uint32_t led, uint8_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = value };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_LED_SET_BRIGHTNESS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_set_brightness(dev, led, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_set_brightness(dev, led, value) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_SET_BRIGHTNESS, led_set_brightness, dev, led, value); syscall__retval = led_set_brightness(dev, led, value); sys_port_trace_syscall_exit(K_SYSCALL_LED_SET_BRIGHTNESS, led_set_brightness, dev, led, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_led_write_channels(const struct device * dev, uint32_t start_channel, uint32_t num_channels, const uint8_t * buf);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_write_channels(const struct device * dev, uint32_t start_channel, uint32_t num_channels, const uint8_t * buf)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = start_channel };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = num_channels };
|
||||
union { uintptr_t x; const uint8_t * val; } parm3 = { .val = buf };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_LED_WRITE_CHANNELS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_write_channels(dev, start_channel, num_channels, buf);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_write_channels(dev, start_channel, num_channels, buf) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_WRITE_CHANNELS, led_write_channels, dev, start_channel, num_channels, buf); syscall__retval = led_write_channels(dev, start_channel, num_channels, buf); sys_port_trace_syscall_exit(K_SYSCALL_LED_WRITE_CHANNELS, led_write_channels, dev, start_channel, num_channels, buf, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_led_set_channel(const struct device * dev, uint32_t channel, uint8_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_set_channel(const struct device * dev, uint32_t channel, uint8_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = value };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_LED_SET_CHANNEL);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_set_channel(dev, channel, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_set_channel(dev, channel, value) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_SET_CHANNEL, led_set_channel, dev, channel, value); syscall__retval = led_set_channel(dev, channel, value); sys_port_trace_syscall_exit(K_SYSCALL_LED_SET_CHANNEL, led_set_channel, dev, channel, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_led_set_color(const struct device * dev, uint32_t led, uint8_t num_colors, const uint8_t * color);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_set_color(const struct device * dev, uint32_t led, uint8_t num_colors, const uint8_t * color)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = num_colors };
|
||||
union { uintptr_t x; const uint8_t * val; } parm3 = { .val = color };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_LED_SET_COLOR);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_set_color(dev, led, num_colors, color);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_set_color(dev, led, num_colors, color) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_SET_COLOR, led_set_color, dev, led, num_colors, color); syscall__retval = led_set_color(dev, led, num_colors, color); sys_port_trace_syscall_exit(K_SYSCALL_LED_SET_COLOR, led_set_color, dev, led, num_colors, color, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_led_on(const struct device * dev, uint32_t led);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_on(const struct device * dev, uint32_t led)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_LED_ON);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_on(dev, led);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_on(dev, led) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_ON, led_on, dev, led); syscall__retval = led_on(dev, led); sys_port_trace_syscall_exit(K_SYSCALL_LED_ON, led_on, dev, led, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_led_off(const struct device * dev, uint32_t led);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_off(const struct device * dev, uint32_t led)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_LED_OFF);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_off(dev, led);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_off(dev, led) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_OFF, led_off, dev, led); syscall__retval = led_off(dev, led); sys_port_trace_syscall_exit(K_SYSCALL_LED_OFF, led_off, dev, led, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
126
build/zephyr/include/generated/zephyr/syscalls/libc-hooks.h
Normal file
126
build/zephyr/include/generated/zephyr/syscalls/libc-hooks.h
Normal file
@@ -0,0 +1,126 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_LIBC_HOOKS_H
|
||||
#define Z_INCLUDE_SYSCALLS_LIBC_HOOKS_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_zephyr_read_stdin(char * buf, int nbytes);
|
||||
|
||||
__pinned_func
|
||||
static inline int zephyr_read_stdin(char * buf, int nbytes)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; char * val; } parm0 = { .val = buf };
|
||||
union { uintptr_t x; int val; } parm1 = { .val = nbytes };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ZEPHYR_READ_STDIN);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_zephyr_read_stdin(buf, nbytes);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define zephyr_read_stdin(buf, nbytes) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ZEPHYR_READ_STDIN, zephyr_read_stdin, buf, nbytes); syscall__retval = zephyr_read_stdin(buf, nbytes); sys_port_trace_syscall_exit(K_SYSCALL_ZEPHYR_READ_STDIN, zephyr_read_stdin, buf, nbytes, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_zephyr_write_stdout(const void * buf, int nbytes);
|
||||
|
||||
__pinned_func
|
||||
static inline int zephyr_write_stdout(const void * buf, int nbytes)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void * val; } parm0 = { .val = buf };
|
||||
union { uintptr_t x; int val; } parm1 = { .val = nbytes };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ZEPHYR_WRITE_STDOUT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_zephyr_write_stdout(buf, nbytes);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define zephyr_write_stdout(buf, nbytes) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ZEPHYR_WRITE_STDOUT, zephyr_write_stdout, buf, nbytes); syscall__retval = zephyr_write_stdout(buf, nbytes); sys_port_trace_syscall_exit(K_SYSCALL_ZEPHYR_WRITE_STDOUT, zephyr_write_stdout, buf, nbytes, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_zephyr_fputc(int c, FILE * stream);
|
||||
|
||||
__pinned_func
|
||||
static inline int zephyr_fputc(int c, FILE * stream)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = c };
|
||||
union { uintptr_t x; FILE * val; } parm1 = { .val = stream };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ZEPHYR_FPUTC);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_zephyr_fputc(c, stream);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define zephyr_fputc(c, stream) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ZEPHYR_FPUTC, zephyr_fputc, c, stream); syscall__retval = zephyr_fputc(c, stream); sys_port_trace_syscall_exit(K_SYSCALL_ZEPHYR_FPUTC, zephyr_fputc, c, stream, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern size_t z_impl_zephyr_fwrite(const void *ZRESTRICT ptr, size_t size, size_t nitems, FILE *ZRESTRICT stream);
|
||||
|
||||
__pinned_func
|
||||
static inline size_t zephyr_fwrite(const void *ZRESTRICT ptr, size_t size, size_t nitems, FILE *ZRESTRICT stream)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void *ZRESTRICT val; } parm0 = { .val = ptr };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = size };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = nitems };
|
||||
union { uintptr_t x; FILE *ZRESTRICT val; } parm3 = { .val = stream };
|
||||
return (size_t) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_ZEPHYR_FWRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_zephyr_fwrite(ptr, size, nitems, stream);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define zephyr_fwrite(ptr, size, nitems, stream) ({ size_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ZEPHYR_FWRITE, zephyr_fwrite, ptr, size, nitems, stream); syscall__retval = zephyr_fwrite(ptr, size, nitems, stream); sys_port_trace_syscall_exit(K_SYSCALL_ZEPHYR_FWRITE, zephyr_fwrite, ptr, size, nitems, stream, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
54
build/zephyr/include/generated/zephyr/syscalls/llext.h
Normal file
54
build/zephyr/include/generated/zephyr/syscalls/llext.h
Normal file
@@ -0,0 +1,54 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_LLEXT_H
|
||||
#define Z_INCLUDE_SYSCALLS_LLEXT_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern ssize_t z_impl_llext_get_fn_table(struct llext * ext, bool is_init, void * buf, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline ssize_t llext_get_fn_table(struct llext * ext, bool is_init, void * buf, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct llext * val; } parm0 = { .val = ext };
|
||||
union { uintptr_t x; bool val; } parm1 = { .val = is_init };
|
||||
union { uintptr_t x; void * val; } parm2 = { .val = buf };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = size };
|
||||
return (ssize_t) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_LLEXT_GET_FN_TABLE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_llext_get_fn_table(ext, is_init, buf, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define llext_get_fn_table(ext, is_init, buf, size) ({ ssize_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LLEXT_GET_FN_TABLE, llext_get_fn_table, ext, is_init, buf, size); syscall__retval = llext_get_fn_table(ext, is_init, buf, size); sys_port_trace_syscall_exit(K_SYSCALL_LLEXT_GET_FN_TABLE, llext_get_fn_table, ext, is_init, buf, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
145
build/zephyr/include/generated/zephyr/syscalls/log_ctrl.h
Normal file
145
build/zephyr/include/generated/zephyr/syscalls/log_ctrl.h
Normal file
@@ -0,0 +1,145 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_LOG_CTRL_H
|
||||
#define Z_INCLUDE_SYSCALLS_LOG_CTRL_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_log_panic(void);
|
||||
|
||||
__pinned_func
|
||||
static inline void log_panic(void)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
(void) arch_syscall_invoke0(K_SYSCALL_LOG_PANIC);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_log_panic();
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define log_panic() do { sys_port_trace_syscall_enter(K_SYSCALL_LOG_PANIC, log_panic); log_panic(); sys_port_trace_syscall_exit(K_SYSCALL_LOG_PANIC, log_panic); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_log_process(void);
|
||||
|
||||
__pinned_func
|
||||
static inline bool log_process(void)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
return (bool) arch_syscall_invoke0(K_SYSCALL_LOG_PROCESS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_log_process();
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define log_process() ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LOG_PROCESS, log_process); syscall__retval = log_process(); sys_port_trace_syscall_exit(K_SYSCALL_LOG_PROCESS, log_process, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_log_buffered_cnt(void);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t log_buffered_cnt(void)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
return (uint32_t) arch_syscall_invoke0(K_SYSCALL_LOG_BUFFERED_CNT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_log_buffered_cnt();
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define log_buffered_cnt() ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LOG_BUFFERED_CNT, log_buffered_cnt); syscall__retval = log_buffered_cnt(); sys_port_trace_syscall_exit(K_SYSCALL_LOG_BUFFERED_CNT, log_buffered_cnt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_log_filter_set(struct log_backend const *const backend, uint32_t domain_id, int16_t source_id, uint32_t level);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t log_filter_set(struct log_backend const *const backend, uint32_t domain_id, int16_t source_id, uint32_t level)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct log_backend const *const val; } parm0 = { .val = backend };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = domain_id };
|
||||
union { uintptr_t x; int16_t val; } parm2 = { .val = source_id };
|
||||
union { uintptr_t x; uint32_t val; } parm3 = { .val = level };
|
||||
return (uint32_t) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_LOG_FILTER_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_log_filter_set(backend, domain_id, source_id, level);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define log_filter_set(backend, domain_id, source_id, level) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LOG_FILTER_SET, log_filter_set, backend, domain_id, source_id, level); syscall__retval = log_filter_set(backend, domain_id, source_id, level); sys_port_trace_syscall_exit(K_SYSCALL_LOG_FILTER_SET, log_filter_set, backend, domain_id, source_id, level, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_log_frontend_filter_set(int16_t source_id, uint32_t level);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t log_frontend_filter_set(int16_t source_id, uint32_t level)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int16_t val; } parm0 = { .val = source_id };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = level };
|
||||
return (uint32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_LOG_FRONTEND_FILTER_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_log_frontend_filter_set(source_id, level);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define log_frontend_filter_set(source_id, level) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LOG_FRONTEND_FILTER_SET, log_frontend_filter_set, source_id, level); syscall__retval = log_frontend_filter_set(source_id, level); sys_port_trace_syscall_exit(K_SYSCALL_LOG_FRONTEND_FILTER_SET, log_frontend_filter_set, source_id, level, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
136
build/zephyr/include/generated/zephyr/syscalls/log_msg.h
Normal file
136
build/zephyr/include/generated/zephyr/syscalls/log_msg.h
Normal file
@@ -0,0 +1,136 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_LOG_MSG_H
|
||||
#define Z_INCLUDE_SYSCALLS_LOG_MSG_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_z_log_msg_simple_create_0(const void * source, uint32_t level, const char * fmt);
|
||||
|
||||
__pinned_func
|
||||
static inline void z_log_msg_simple_create_0(const void * source, uint32_t level, const char * fmt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void * val; } parm0 = { .val = source };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = level };
|
||||
union { uintptr_t x; const char * val; } parm2 = { .val = fmt };
|
||||
(void) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_z_log_msg_simple_create_0(source, level, fmt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define z_log_msg_simple_create_0(source, level, fmt) do { sys_port_trace_syscall_enter(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0, z_log_msg_simple_create_0, source, level, fmt); z_log_msg_simple_create_0(source, level, fmt); sys_port_trace_syscall_exit(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0, z_log_msg_simple_create_0, source, level, fmt); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_z_log_msg_simple_create_1(const void * source, uint32_t level, const char * fmt, uint32_t arg);
|
||||
|
||||
__pinned_func
|
||||
static inline void z_log_msg_simple_create_1(const void * source, uint32_t level, const char * fmt, uint32_t arg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void * val; } parm0 = { .val = source };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = level };
|
||||
union { uintptr_t x; const char * val; } parm2 = { .val = fmt };
|
||||
union { uintptr_t x; uint32_t val; } parm3 = { .val = arg };
|
||||
(void) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_z_log_msg_simple_create_1(source, level, fmt, arg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define z_log_msg_simple_create_1(source, level, fmt, arg) do { sys_port_trace_syscall_enter(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1, z_log_msg_simple_create_1, source, level, fmt, arg); z_log_msg_simple_create_1(source, level, fmt, arg); sys_port_trace_syscall_exit(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1, z_log_msg_simple_create_1, source, level, fmt, arg); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_z_log_msg_simple_create_2(const void * source, uint32_t level, const char * fmt, uint32_t arg0, uint32_t arg1);
|
||||
|
||||
__pinned_func
|
||||
static inline void z_log_msg_simple_create_2(const void * source, uint32_t level, const char * fmt, uint32_t arg0, uint32_t arg1)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void * val; } parm0 = { .val = source };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = level };
|
||||
union { uintptr_t x; const char * val; } parm2 = { .val = fmt };
|
||||
union { uintptr_t x; uint32_t val; } parm3 = { .val = arg0 };
|
||||
union { uintptr_t x; uint32_t val; } parm4 = { .val = arg1 };
|
||||
(void) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_z_log_msg_simple_create_2(source, level, fmt, arg0, arg1);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define z_log_msg_simple_create_2(source, level, fmt, arg0, arg1) do { sys_port_trace_syscall_enter(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2, z_log_msg_simple_create_2, source, level, fmt, arg0, arg1); z_log_msg_simple_create_2(source, level, fmt, arg0, arg1); sys_port_trace_syscall_exit(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2, z_log_msg_simple_create_2, source, level, fmt, arg0, arg1); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_z_log_msg_static_create(const void * source, const struct log_msg_desc desc, uint8_t * package, const void * data);
|
||||
|
||||
__pinned_func
|
||||
static inline void z_log_msg_static_create(const void * source, const struct log_msg_desc desc, uint8_t * package, const void * data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void * val; } parm0 = { .val = source };
|
||||
union { uintptr_t x; const struct log_msg_desc val; } parm1 = { .val = desc };
|
||||
union { uintptr_t x; uint8_t * val; } parm2 = { .val = package };
|
||||
union { uintptr_t x; const void * val; } parm3 = { .val = data };
|
||||
(void) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_Z_LOG_MSG_STATIC_CREATE);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_z_log_msg_static_create(source, desc, package, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define z_log_msg_static_create(source, desc, package, data) do { sys_port_trace_syscall_enter(K_SYSCALL_Z_LOG_MSG_STATIC_CREATE, z_log_msg_static_create, source, desc, package, data); z_log_msg_static_create(source, desc, package, data); sys_port_trace_syscall_exit(K_SYSCALL_Z_LOG_MSG_STATIC_CREATE, z_log_msg_static_create, source, desc, package, data); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,76 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_MAXIM_DS3231_H
|
||||
#define Z_INCLUDE_SYSCALLS_MAXIM_DS3231_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_maxim_ds3231_req_syncpoint(const struct device * dev, struct k_poll_signal * signal);
|
||||
|
||||
__pinned_func
|
||||
static inline int maxim_ds3231_req_syncpoint(const struct device * dev, struct k_poll_signal * signal)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct k_poll_signal * val; } parm1 = { .val = signal };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_maxim_ds3231_req_syncpoint(dev, signal);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define maxim_ds3231_req_syncpoint(dev, signal) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT, maxim_ds3231_req_syncpoint, dev, signal); syscall__retval = maxim_ds3231_req_syncpoint(dev, signal); sys_port_trace_syscall_exit(K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT, maxim_ds3231_req_syncpoint, dev, signal, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_maxim_ds3231_get_syncpoint(const struct device * dev, struct maxim_ds3231_syncpoint * syncpoint);
|
||||
|
||||
__pinned_func
|
||||
static inline int maxim_ds3231_get_syncpoint(const struct device * dev, struct maxim_ds3231_syncpoint * syncpoint)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct maxim_ds3231_syncpoint * val; } parm1 = { .val = syncpoint };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_maxim_ds3231_get_syncpoint(dev, syncpoint);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define maxim_ds3231_get_syncpoint(dev, syncpoint) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT, maxim_ds3231_get_syncpoint, dev, syncpoint); syscall__retval = maxim_ds3231_get_syncpoint(dev, syncpoint); sys_port_trace_syscall_exit(K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT, maxim_ds3231_get_syncpoint, dev, syncpoint, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
124
build/zephyr/include/generated/zephyr/syscalls/mbox.h
Normal file
124
build/zephyr/include/generated/zephyr/syscalls/mbox.h
Normal file
@@ -0,0 +1,124 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_MBOX_H
|
||||
#define Z_INCLUDE_SYSCALLS_MBOX_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_mbox_send(const struct device * dev, mbox_channel_id_t channel_id, const struct mbox_msg * msg);
|
||||
|
||||
__pinned_func
|
||||
static inline int mbox_send(const struct device * dev, mbox_channel_id_t channel_id, const struct mbox_msg * msg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; mbox_channel_id_t val; } parm1 = { .val = channel_id };
|
||||
union { uintptr_t x; const struct mbox_msg * val; } parm2 = { .val = msg };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_MBOX_SEND);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mbox_send(dev, channel_id, msg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mbox_send(dev, channel_id, msg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MBOX_SEND, mbox_send, dev, channel_id, msg); syscall__retval = mbox_send(dev, channel_id, msg); sys_port_trace_syscall_exit(K_SYSCALL_MBOX_SEND, mbox_send, dev, channel_id, msg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mbox_mtu_get(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int mbox_mtu_get(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_MBOX_MTU_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mbox_mtu_get(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mbox_mtu_get(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MBOX_MTU_GET, mbox_mtu_get, dev); syscall__retval = mbox_mtu_get(dev); sys_port_trace_syscall_exit(K_SYSCALL_MBOX_MTU_GET, mbox_mtu_get, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mbox_set_enabled(const struct device * dev, mbox_channel_id_t channel_id, bool enabled);
|
||||
|
||||
__pinned_func
|
||||
static inline int mbox_set_enabled(const struct device * dev, mbox_channel_id_t channel_id, bool enabled)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; mbox_channel_id_t val; } parm1 = { .val = channel_id };
|
||||
union { uintptr_t x; bool val; } parm2 = { .val = enabled };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_MBOX_SET_ENABLED);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mbox_set_enabled(dev, channel_id, enabled);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mbox_set_enabled(dev, channel_id, enabled) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MBOX_SET_ENABLED, mbox_set_enabled, dev, channel_id, enabled); syscall__retval = mbox_set_enabled(dev, channel_id, enabled); sys_port_trace_syscall_exit(K_SYSCALL_MBOX_SET_ENABLED, mbox_set_enabled, dev, channel_id, enabled, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_mbox_max_channels_get(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t mbox_max_channels_get(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_MBOX_MAX_CHANNELS_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mbox_max_channels_get(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mbox_max_channels_get(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MBOX_MAX_CHANNELS_GET, mbox_max_channels_get, dev); syscall__retval = mbox_max_channels_get(dev); sys_port_trace_syscall_exit(K_SYSCALL_MBOX_MAX_CHANNELS_GET, mbox_max_channels_get, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
134
build/zephyr/include/generated/zephyr/syscalls/mdio.h
Normal file
134
build/zephyr/include/generated/zephyr/syscalls/mdio.h
Normal file
@@ -0,0 +1,134 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_MDIO_H
|
||||
#define Z_INCLUDE_SYSCALLS_MDIO_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_mdio_read(const struct device * dev, uint8_t prtad, uint8_t regad, uint16_t * data);
|
||||
|
||||
__pinned_func
|
||||
static inline int mdio_read(const struct device * dev, uint8_t prtad, uint8_t regad, uint16_t * data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = prtad };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = regad };
|
||||
union { uintptr_t x; uint16_t * val; } parm3 = { .val = data };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_MDIO_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mdio_read(dev, prtad, regad, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mdio_read(dev, prtad, regad, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MDIO_READ, mdio_read, dev, prtad, regad, data); syscall__retval = mdio_read(dev, prtad, regad, data); sys_port_trace_syscall_exit(K_SYSCALL_MDIO_READ, mdio_read, dev, prtad, regad, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mdio_write(const struct device * dev, uint8_t prtad, uint8_t regad, uint16_t data);
|
||||
|
||||
__pinned_func
|
||||
static inline int mdio_write(const struct device * dev, uint8_t prtad, uint8_t regad, uint16_t data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = prtad };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = regad };
|
||||
union { uintptr_t x; uint16_t val; } parm3 = { .val = data };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_MDIO_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mdio_write(dev, prtad, regad, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mdio_write(dev, prtad, regad, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MDIO_WRITE, mdio_write, dev, prtad, regad, data); syscall__retval = mdio_write(dev, prtad, regad, data); sys_port_trace_syscall_exit(K_SYSCALL_MDIO_WRITE, mdio_write, dev, prtad, regad, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mdio_read_c45(const struct device * dev, uint8_t prtad, uint8_t devad, uint16_t regad, uint16_t * data);
|
||||
|
||||
__pinned_func
|
||||
static inline int mdio_read_c45(const struct device * dev, uint8_t prtad, uint8_t devad, uint16_t regad, uint16_t * data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = prtad };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = devad };
|
||||
union { uintptr_t x; uint16_t val; } parm3 = { .val = regad };
|
||||
union { uintptr_t x; uint16_t * val; } parm4 = { .val = data };
|
||||
return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_MDIO_READ_C45);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mdio_read_c45(dev, prtad, devad, regad, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mdio_read_c45(dev, prtad, devad, regad, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MDIO_READ_C45, mdio_read_c45, dev, prtad, devad, regad, data); syscall__retval = mdio_read_c45(dev, prtad, devad, regad, data); sys_port_trace_syscall_exit(K_SYSCALL_MDIO_READ_C45, mdio_read_c45, dev, prtad, devad, regad, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mdio_write_c45(const struct device * dev, uint8_t prtad, uint8_t devad, uint16_t regad, uint16_t data);
|
||||
|
||||
__pinned_func
|
||||
static inline int mdio_write_c45(const struct device * dev, uint8_t prtad, uint8_t devad, uint16_t regad, uint16_t data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = prtad };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = devad };
|
||||
union { uintptr_t x; uint16_t val; } parm3 = { .val = regad };
|
||||
union { uintptr_t x; uint16_t val; } parm4 = { .val = data };
|
||||
return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_MDIO_WRITE_C45);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mdio_write_c45(dev, prtad, devad, regad, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mdio_write_c45(dev, prtad, devad, regad, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MDIO_WRITE_C45, mdio_write_c45, dev, prtad, devad, regad, data); syscall__retval = mdio_write_c45(dev, prtad, devad, regad, data); sys_port_trace_syscall_exit(K_SYSCALL_MDIO_WRITE_C45, mdio_write_c45, dev, prtad, devad, regad, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
202
build/zephyr/include/generated/zephyr/syscalls/mspi.h
Normal file
202
build/zephyr/include/generated/zephyr/syscalls/mspi.h
Normal file
@@ -0,0 +1,202 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_MSPI_H
|
||||
#define Z_INCLUDE_SYSCALLS_MSPI_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_mspi_config(const struct mspi_dt_spec * spec);
|
||||
|
||||
__pinned_func
|
||||
static inline int mspi_config(const struct mspi_dt_spec * spec)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct mspi_dt_spec * val; } parm0 = { .val = spec };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_MSPI_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mspi_config(spec);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mspi_config(spec) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MSPI_CONFIG, mspi_config, spec); syscall__retval = mspi_config(spec); sys_port_trace_syscall_exit(K_SYSCALL_MSPI_CONFIG, mspi_config, spec, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mspi_dev_config(const struct device * controller, const struct mspi_dev_id * dev_id, const enum mspi_dev_cfg_mask param_mask, const struct mspi_dev_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int mspi_dev_config(const struct device * controller, const struct mspi_dev_id * dev_id, const enum mspi_dev_cfg_mask param_mask, const struct mspi_dev_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = controller };
|
||||
union { uintptr_t x; const struct mspi_dev_id * val; } parm1 = { .val = dev_id };
|
||||
union { uintptr_t x; const enum mspi_dev_cfg_mask val; } parm2 = { .val = param_mask };
|
||||
union { uintptr_t x; const struct mspi_dev_cfg * val; } parm3 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_MSPI_DEV_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mspi_dev_config(controller, dev_id, param_mask, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mspi_dev_config(controller, dev_id, param_mask, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MSPI_DEV_CONFIG, mspi_dev_config, controller, dev_id, param_mask, cfg); syscall__retval = mspi_dev_config(controller, dev_id, param_mask, cfg); sys_port_trace_syscall_exit(K_SYSCALL_MSPI_DEV_CONFIG, mspi_dev_config, controller, dev_id, param_mask, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mspi_get_channel_status(const struct device * controller, uint8_t ch);
|
||||
|
||||
__pinned_func
|
||||
static inline int mspi_get_channel_status(const struct device * controller, uint8_t ch)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = controller };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = ch };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_MSPI_GET_CHANNEL_STATUS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mspi_get_channel_status(controller, ch);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mspi_get_channel_status(controller, ch) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MSPI_GET_CHANNEL_STATUS, mspi_get_channel_status, controller, ch); syscall__retval = mspi_get_channel_status(controller, ch); sys_port_trace_syscall_exit(K_SYSCALL_MSPI_GET_CHANNEL_STATUS, mspi_get_channel_status, controller, ch, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mspi_transceive(const struct device * controller, const struct mspi_dev_id * dev_id, const struct mspi_xfer * req);
|
||||
|
||||
__pinned_func
|
||||
static inline int mspi_transceive(const struct device * controller, const struct mspi_dev_id * dev_id, const struct mspi_xfer * req)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = controller };
|
||||
union { uintptr_t x; const struct mspi_dev_id * val; } parm1 = { .val = dev_id };
|
||||
union { uintptr_t x; const struct mspi_xfer * val; } parm2 = { .val = req };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_MSPI_TRANSCEIVE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mspi_transceive(controller, dev_id, req);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mspi_transceive(controller, dev_id, req) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MSPI_TRANSCEIVE, mspi_transceive, controller, dev_id, req); syscall__retval = mspi_transceive(controller, dev_id, req); sys_port_trace_syscall_exit(K_SYSCALL_MSPI_TRANSCEIVE, mspi_transceive, controller, dev_id, req, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mspi_xip_config(const struct device * controller, const struct mspi_dev_id * dev_id, const struct mspi_xip_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int mspi_xip_config(const struct device * controller, const struct mspi_dev_id * dev_id, const struct mspi_xip_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = controller };
|
||||
union { uintptr_t x; const struct mspi_dev_id * val; } parm1 = { .val = dev_id };
|
||||
union { uintptr_t x; const struct mspi_xip_cfg * val; } parm2 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_MSPI_XIP_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mspi_xip_config(controller, dev_id, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mspi_xip_config(controller, dev_id, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MSPI_XIP_CONFIG, mspi_xip_config, controller, dev_id, cfg); syscall__retval = mspi_xip_config(controller, dev_id, cfg); sys_port_trace_syscall_exit(K_SYSCALL_MSPI_XIP_CONFIG, mspi_xip_config, controller, dev_id, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mspi_scramble_config(const struct device * controller, const struct mspi_dev_id * dev_id, const struct mspi_scramble_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int mspi_scramble_config(const struct device * controller, const struct mspi_dev_id * dev_id, const struct mspi_scramble_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = controller };
|
||||
union { uintptr_t x; const struct mspi_dev_id * val; } parm1 = { .val = dev_id };
|
||||
union { uintptr_t x; const struct mspi_scramble_cfg * val; } parm2 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_MSPI_SCRAMBLE_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mspi_scramble_config(controller, dev_id, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mspi_scramble_config(controller, dev_id, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MSPI_SCRAMBLE_CONFIG, mspi_scramble_config, controller, dev_id, cfg); syscall__retval = mspi_scramble_config(controller, dev_id, cfg); sys_port_trace_syscall_exit(K_SYSCALL_MSPI_SCRAMBLE_CONFIG, mspi_scramble_config, controller, dev_id, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mspi_timing_config(const struct device * controller, const struct mspi_dev_id * dev_id, const uint32_t param_mask, void * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int mspi_timing_config(const struct device * controller, const struct mspi_dev_id * dev_id, const uint32_t param_mask, void * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = controller };
|
||||
union { uintptr_t x; const struct mspi_dev_id * val; } parm1 = { .val = dev_id };
|
||||
union { uintptr_t x; const uint32_t val; } parm2 = { .val = param_mask };
|
||||
union { uintptr_t x; void * val; } parm3 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_MSPI_TIMING_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mspi_timing_config(controller, dev_id, param_mask, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mspi_timing_config(controller, dev_id, param_mask, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MSPI_TIMING_CONFIG, mspi_timing_config, controller, dev_id, param_mask, cfg); syscall__retval = mspi_timing_config(controller, dev_id, param_mask, cfg); sys_port_trace_syscall_exit(K_SYSCALL_MSPI_TIMING_CONFIG, mspi_timing_config, controller, dev_id, param_mask, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
75
build/zephyr/include/generated/zephyr/syscalls/mutex.h
Normal file
75
build/zephyr/include/generated/zephyr/syscalls/mutex.h
Normal file
@@ -0,0 +1,75 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_MUTEX_H
|
||||
#define Z_INCLUDE_SYSCALLS_MUTEX_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_z_sys_mutex_kernel_lock(struct sys_mutex * mutex, k_timeout_t timeout);
|
||||
|
||||
__pinned_func
|
||||
static inline int z_sys_mutex_kernel_lock(struct sys_mutex * mutex, k_timeout_t timeout)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct sys_mutex * val; } parm0 = { .val = mutex };
|
||||
union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm1 = { .val = timeout };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.split.lo, parm1.split.hi, K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_z_sys_mutex_kernel_lock(mutex, timeout);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define z_sys_mutex_kernel_lock(mutex, timeout) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK, z_sys_mutex_kernel_lock, mutex, timeout); syscall__retval = z_sys_mutex_kernel_lock(mutex, timeout); sys_port_trace_syscall_exit(K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK, z_sys_mutex_kernel_lock, mutex, timeout, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_z_sys_mutex_kernel_unlock(struct sys_mutex * mutex);
|
||||
|
||||
__pinned_func
|
||||
static inline int z_sys_mutex_kernel_unlock(struct sys_mutex * mutex)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct sys_mutex * val; } parm0 = { .val = mutex };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_z_sys_mutex_kernel_unlock(mutex);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define z_sys_mutex_kernel_unlock(mutex) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK, z_sys_mutex_kernel_unlock, mutex); syscall__retval = z_sys_mutex_kernel_unlock(mutex); sys_port_trace_syscall_exit(K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK, z_sys_mutex_kernel_unlock, mutex, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
270
build/zephyr/include/generated/zephyr/syscalls/net_if.h
Normal file
270
build/zephyr/include/generated/zephyr/syscalls/net_if.h
Normal file
@@ -0,0 +1,270 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_NET_IF_H
|
||||
#define Z_INCLUDE_SYSCALLS_NET_IF_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_net_if_ipv6_addr_lookup_by_index(const struct net_in6_addr * addr);
|
||||
|
||||
__pinned_func
|
||||
static inline int net_if_ipv6_addr_lookup_by_index(const struct net_in6_addr * addr)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct net_in6_addr * val; } parm0 = { .val = addr };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_NET_IF_IPV6_ADDR_LOOKUP_BY_INDEX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_if_ipv6_addr_lookup_by_index(addr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_if_ipv6_addr_lookup_by_index(addr) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV6_ADDR_LOOKUP_BY_INDEX, net_if_ipv6_addr_lookup_by_index, addr); syscall__retval = net_if_ipv6_addr_lookup_by_index(addr); sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV6_ADDR_LOOKUP_BY_INDEX, net_if_ipv6_addr_lookup_by_index, addr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_net_if_ipv6_addr_add_by_index(int index, const struct net_in6_addr * addr, enum net_addr_type addr_type, uint32_t vlifetime);
|
||||
|
||||
__pinned_func
|
||||
static inline bool net_if_ipv6_addr_add_by_index(int index, const struct net_in6_addr * addr, enum net_addr_type addr_type, uint32_t vlifetime)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = index };
|
||||
union { uintptr_t x; const struct net_in6_addr * val; } parm1 = { .val = addr };
|
||||
union { uintptr_t x; enum net_addr_type val; } parm2 = { .val = addr_type };
|
||||
union { uintptr_t x; uint32_t val; } parm3 = { .val = vlifetime };
|
||||
return (bool) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_NET_IF_IPV6_ADDR_ADD_BY_INDEX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_if_ipv6_addr_add_by_index(index, addr, addr_type, vlifetime);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_if_ipv6_addr_add_by_index(index, addr, addr_type, vlifetime) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV6_ADDR_ADD_BY_INDEX, net_if_ipv6_addr_add_by_index, index, addr, addr_type, vlifetime); syscall__retval = net_if_ipv6_addr_add_by_index(index, addr, addr_type, vlifetime); sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV6_ADDR_ADD_BY_INDEX, net_if_ipv6_addr_add_by_index, index, addr, addr_type, vlifetime, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_net_if_ipv6_addr_rm_by_index(int index, const struct net_in6_addr * addr);
|
||||
|
||||
__pinned_func
|
||||
static inline bool net_if_ipv6_addr_rm_by_index(int index, const struct net_in6_addr * addr)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = index };
|
||||
union { uintptr_t x; const struct net_in6_addr * val; } parm1 = { .val = addr };
|
||||
return (bool) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_NET_IF_IPV6_ADDR_RM_BY_INDEX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_if_ipv6_addr_rm_by_index(index, addr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_if_ipv6_addr_rm_by_index(index, addr) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV6_ADDR_RM_BY_INDEX, net_if_ipv6_addr_rm_by_index, index, addr); syscall__retval = net_if_ipv6_addr_rm_by_index(index, addr); sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV6_ADDR_RM_BY_INDEX, net_if_ipv6_addr_rm_by_index, index, addr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_net_if_ipv4_addr_lookup_by_index(const struct net_in_addr * addr);
|
||||
|
||||
__pinned_func
|
||||
static inline int net_if_ipv4_addr_lookup_by_index(const struct net_in_addr * addr)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct net_in_addr * val; } parm0 = { .val = addr };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_NET_IF_IPV4_ADDR_LOOKUP_BY_INDEX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_if_ipv4_addr_lookup_by_index(addr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_if_ipv4_addr_lookup_by_index(addr) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV4_ADDR_LOOKUP_BY_INDEX, net_if_ipv4_addr_lookup_by_index, addr); syscall__retval = net_if_ipv4_addr_lookup_by_index(addr); sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV4_ADDR_LOOKUP_BY_INDEX, net_if_ipv4_addr_lookup_by_index, addr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_net_if_ipv4_addr_add_by_index(int index, const struct net_in_addr * addr, enum net_addr_type addr_type, uint32_t vlifetime);
|
||||
|
||||
__pinned_func
|
||||
static inline bool net_if_ipv4_addr_add_by_index(int index, const struct net_in_addr * addr, enum net_addr_type addr_type, uint32_t vlifetime)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = index };
|
||||
union { uintptr_t x; const struct net_in_addr * val; } parm1 = { .val = addr };
|
||||
union { uintptr_t x; enum net_addr_type val; } parm2 = { .val = addr_type };
|
||||
union { uintptr_t x; uint32_t val; } parm3 = { .val = vlifetime };
|
||||
return (bool) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_NET_IF_IPV4_ADDR_ADD_BY_INDEX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_if_ipv4_addr_add_by_index(index, addr, addr_type, vlifetime);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_if_ipv4_addr_add_by_index(index, addr, addr_type, vlifetime) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV4_ADDR_ADD_BY_INDEX, net_if_ipv4_addr_add_by_index, index, addr, addr_type, vlifetime); syscall__retval = net_if_ipv4_addr_add_by_index(index, addr, addr_type, vlifetime); sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV4_ADDR_ADD_BY_INDEX, net_if_ipv4_addr_add_by_index, index, addr, addr_type, vlifetime, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_net_if_ipv4_addr_rm_by_index(int index, const struct net_in_addr * addr);
|
||||
|
||||
__pinned_func
|
||||
static inline bool net_if_ipv4_addr_rm_by_index(int index, const struct net_in_addr * addr)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = index };
|
||||
union { uintptr_t x; const struct net_in_addr * val; } parm1 = { .val = addr };
|
||||
return (bool) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_if_ipv4_addr_rm_by_index(index, addr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_if_ipv4_addr_rm_by_index(index, addr) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX, net_if_ipv4_addr_rm_by_index, index, addr); syscall__retval = net_if_ipv4_addr_rm_by_index(index, addr); sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX, net_if_ipv4_addr_rm_by_index, index, addr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_net_if_ipv4_set_netmask_by_index(int index, const struct net_in_addr * netmask);
|
||||
|
||||
__pinned_func
|
||||
static inline bool net_if_ipv4_set_netmask_by_index(int index, const struct net_in_addr * netmask)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = index };
|
||||
union { uintptr_t x; const struct net_in_addr * val; } parm1 = { .val = netmask };
|
||||
return (bool) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_INDEX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_if_ipv4_set_netmask_by_index(index, netmask);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_if_ipv4_set_netmask_by_index(index, netmask) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_INDEX, net_if_ipv4_set_netmask_by_index, index, netmask); syscall__retval = net_if_ipv4_set_netmask_by_index(index, netmask); sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_INDEX, net_if_ipv4_set_netmask_by_index, index, netmask, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_net_if_ipv4_set_netmask_by_addr_by_index(int index, const struct net_in_addr * addr, const struct net_in_addr * netmask);
|
||||
|
||||
__pinned_func
|
||||
static inline bool net_if_ipv4_set_netmask_by_addr_by_index(int index, const struct net_in_addr * addr, const struct net_in_addr * netmask)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = index };
|
||||
union { uintptr_t x; const struct net_in_addr * val; } parm1 = { .val = addr };
|
||||
union { uintptr_t x; const struct net_in_addr * val; } parm2 = { .val = netmask };
|
||||
return (bool) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_ADDR_BY_INDEX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_if_ipv4_set_netmask_by_addr_by_index(index, addr, netmask);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_if_ipv4_set_netmask_by_addr_by_index(index, addr, netmask) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_ADDR_BY_INDEX, net_if_ipv4_set_netmask_by_addr_by_index, index, addr, netmask); syscall__retval = net_if_ipv4_set_netmask_by_addr_by_index(index, addr, netmask); sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_ADDR_BY_INDEX, net_if_ipv4_set_netmask_by_addr_by_index, index, addr, netmask, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_net_if_ipv4_set_gw_by_index(int index, const struct net_in_addr * gw);
|
||||
|
||||
__pinned_func
|
||||
static inline bool net_if_ipv4_set_gw_by_index(int index, const struct net_in_addr * gw)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = index };
|
||||
union { uintptr_t x; const struct net_in_addr * val; } parm1 = { .val = gw };
|
||||
return (bool) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_NET_IF_IPV4_SET_GW_BY_INDEX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_if_ipv4_set_gw_by_index(index, gw);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_if_ipv4_set_gw_by_index(index, gw) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV4_SET_GW_BY_INDEX, net_if_ipv4_set_gw_by_index, index, gw); syscall__retval = net_if_ipv4_set_gw_by_index(index, gw); sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV4_SET_GW_BY_INDEX, net_if_ipv4_set_gw_by_index, index, gw, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern struct net_if * z_impl_net_if_get_by_index(int index);
|
||||
|
||||
__pinned_func
|
||||
static inline struct net_if * net_if_get_by_index(int index)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = index };
|
||||
return (struct net_if *) arch_syscall_invoke1(parm0.x, K_SYSCALL_NET_IF_GET_BY_INDEX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_if_get_by_index(index);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_if_get_by_index(index) ({ struct net_if * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_GET_BY_INDEX, net_if_get_by_index, index); syscall__retval = net_if_get_by_index(index); sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_GET_BY_INDEX, net_if_get_by_index, index, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
79
build/zephyr/include/generated/zephyr/syscalls/net_ip.h
Normal file
79
build/zephyr/include/generated/zephyr/syscalls/net_ip.h
Normal file
@@ -0,0 +1,79 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_NET_IP_H
|
||||
#define Z_INCLUDE_SYSCALLS_NET_IP_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_net_addr_pton(net_sa_family_t family, const char * src, void * dst);
|
||||
|
||||
__pinned_func
|
||||
static inline int net_addr_pton(net_sa_family_t family, const char * src, void * dst)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; net_sa_family_t val; } parm0 = { .val = family };
|
||||
union { uintptr_t x; const char * val; } parm1 = { .val = src };
|
||||
union { uintptr_t x; void * val; } parm2 = { .val = dst };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_NET_ADDR_PTON);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_addr_pton(family, src, dst);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_addr_pton(family, src, dst) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_ADDR_PTON, net_addr_pton, family, src, dst); syscall__retval = net_addr_pton(family, src, dst); sys_port_trace_syscall_exit(K_SYSCALL_NET_ADDR_PTON, net_addr_pton, family, src, dst, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern char * z_impl_net_addr_ntop(net_sa_family_t family, const void * src, char * dst, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline char * net_addr_ntop(net_sa_family_t family, const void * src, char * dst, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; net_sa_family_t val; } parm0 = { .val = family };
|
||||
union { uintptr_t x; const void * val; } parm1 = { .val = src };
|
||||
union { uintptr_t x; char * val; } parm2 = { .val = dst };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = size };
|
||||
return (char *) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_NET_ADDR_NTOP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_addr_ntop(family, src, dst, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_addr_ntop(family, src, dst, size) ({ char * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_ADDR_NTOP, net_addr_ntop, family, src, dst, size); syscall__retval = net_addr_ntop(family, src, dst, size); sys_port_trace_syscall_exit(K_SYSCALL_NET_ADDR_NTOP, net_addr_ntop, family, src, dst, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,53 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_NRF_QSPI_NOR_H
|
||||
#define Z_INCLUDE_SYSCALLS_NRF_QSPI_NOR_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_nrf_qspi_nor_xip_enable(const struct device * dev, bool enable);
|
||||
|
||||
__pinned_func
|
||||
static inline void nrf_qspi_nor_xip_enable(const struct device * dev, bool enable)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; bool val; } parm1 = { .val = enable };
|
||||
(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_nrf_qspi_nor_xip_enable(dev, enable);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define nrf_qspi_nor_xip_enable(dev, enable) do { sys_port_trace_syscall_enter(K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE, nrf_qspi_nor_xip_enable, dev, enable); nrf_qspi_nor_xip_enable(dev, enable); sys_port_trace_syscall_exit(K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE, nrf_qspi_nor_xip_enable, dev, enable); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
52
build/zephyr/include/generated/zephyr/syscalls/opamp.h
Normal file
52
build/zephyr/include/generated/zephyr/syscalls/opamp.h
Normal file
@@ -0,0 +1,52 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_OPAMP_H
|
||||
#define Z_INCLUDE_SYSCALLS_OPAMP_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_opamp_set_gain(const struct device * dev, enum opamp_gain gain);
|
||||
|
||||
__pinned_func
|
||||
static inline int opamp_set_gain(const struct device * dev, enum opamp_gain gain)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum opamp_gain val; } parm1 = { .val = gain };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_OPAMP_SET_GAIN);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_opamp_set_gain(dev, gain);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define opamp_set_gain(dev, gain) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_OPAMP_SET_GAIN, opamp_set_gain, dev, gain); syscall__retval = opamp_set_gain(dev, gain); sys_port_trace_syscall_exit(K_SYSCALL_OPAMP_SET_GAIN, opamp_set_gain, dev, gain, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
80
build/zephyr/include/generated/zephyr/syscalls/otp.h
Normal file
80
build/zephyr/include/generated/zephyr/syscalls/otp.h
Normal file
@@ -0,0 +1,80 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_OTP_H
|
||||
#define Z_INCLUDE_SYSCALLS_OTP_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_otp_read(const struct device * dev, off_t offset, void * data, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int otp_read(const struct device * dev, off_t offset, void * data, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; void * val; } parm2 = { .val = data };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_OTP_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_otp_read(dev, offset, data, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define otp_read(dev, offset, data, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_OTP_READ, otp_read, dev, offset, data, len); syscall__retval = otp_read(dev, offset, data, len); sys_port_trace_syscall_exit(K_SYSCALL_OTP_READ, otp_read, dev, offset, data, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_otp_program(const struct device * dev, off_t offset, const void * data, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int otp_program(const struct device * dev, off_t offset, const void * data, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; const void * val; } parm2 = { .val = data };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_OTP_PROGRAM);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_otp_program(dev, offset, data, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define otp_program(dev, offset, data, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_OTP_PROGRAM, otp_program, dev, offset, data, len); syscall__retval = otp_program(dev, offset, data, len); sys_port_trace_syscall_exit(K_SYSCALL_OTP_PROGRAM, otp_program, dev, offset, data, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
122
build/zephyr/include/generated/zephyr/syscalls/peci.h
Normal file
122
build/zephyr/include/generated/zephyr/syscalls/peci.h
Normal file
@@ -0,0 +1,122 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_PECI_H
|
||||
#define Z_INCLUDE_SYSCALLS_PECI_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_peci_config(const struct device * dev, uint32_t bitrate);
|
||||
|
||||
__pinned_func
|
||||
static inline int peci_config(const struct device * dev, uint32_t bitrate)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = bitrate };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PECI_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_peci_config(dev, bitrate);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define peci_config(dev, bitrate) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PECI_CONFIG, peci_config, dev, bitrate); syscall__retval = peci_config(dev, bitrate); sys_port_trace_syscall_exit(K_SYSCALL_PECI_CONFIG, peci_config, dev, bitrate, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_peci_enable(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int peci_enable(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_PECI_ENABLE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_peci_enable(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define peci_enable(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PECI_ENABLE, peci_enable, dev); syscall__retval = peci_enable(dev); sys_port_trace_syscall_exit(K_SYSCALL_PECI_ENABLE, peci_enable, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_peci_disable(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int peci_disable(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_PECI_DISABLE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_peci_disable(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define peci_disable(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PECI_DISABLE, peci_disable, dev); syscall__retval = peci_disable(dev); sys_port_trace_syscall_exit(K_SYSCALL_PECI_DISABLE, peci_disable, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_peci_transfer(const struct device * dev, struct peci_msg * msg);
|
||||
|
||||
__pinned_func
|
||||
static inline int peci_transfer(const struct device * dev, struct peci_msg * msg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct peci_msg * val; } parm1 = { .val = msg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PECI_TRANSFER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_peci_transfer(dev, msg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define peci_transfer(dev, msg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PECI_TRANSFER, peci_transfer, dev, msg); syscall__retval = peci_transfer(dev, msg); sys_port_trace_syscall_exit(K_SYSCALL_PECI_TRANSFER, peci_transfer, dev, msg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
146
build/zephyr/include/generated/zephyr/syscalls/ps2.h
Normal file
146
build/zephyr/include/generated/zephyr/syscalls/ps2.h
Normal file
@@ -0,0 +1,146 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_PS2_H
|
||||
#define Z_INCLUDE_SYSCALLS_PS2_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_ps2_config(const struct device * dev, ps2_callback_t callback_isr);
|
||||
|
||||
__pinned_func
|
||||
static inline int ps2_config(const struct device * dev, ps2_callback_t callback_isr)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; ps2_callback_t val; } parm1 = { .val = callback_isr };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PS2_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ps2_config(dev, callback_isr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ps2_config(dev, callback_isr) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PS2_CONFIG, ps2_config, dev, callback_isr); syscall__retval = ps2_config(dev, callback_isr); sys_port_trace_syscall_exit(K_SYSCALL_PS2_CONFIG, ps2_config, dev, callback_isr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ps2_write(const struct device * dev, uint8_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline int ps2_write(const struct device * dev, uint8_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = value };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PS2_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ps2_write(dev, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ps2_write(dev, value) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PS2_WRITE, ps2_write, dev, value); syscall__retval = ps2_write(dev, value); sys_port_trace_syscall_exit(K_SYSCALL_PS2_WRITE, ps2_write, dev, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ps2_read(const struct device * dev, uint8_t * value);
|
||||
|
||||
__pinned_func
|
||||
static inline int ps2_read(const struct device * dev, uint8_t * value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t * val; } parm1 = { .val = value };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PS2_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ps2_read(dev, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ps2_read(dev, value) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PS2_READ, ps2_read, dev, value); syscall__retval = ps2_read(dev, value); sys_port_trace_syscall_exit(K_SYSCALL_PS2_READ, ps2_read, dev, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ps2_enable_callback(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int ps2_enable_callback(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_PS2_ENABLE_CALLBACK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ps2_enable_callback(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ps2_enable_callback(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PS2_ENABLE_CALLBACK, ps2_enable_callback, dev); syscall__retval = ps2_enable_callback(dev); sys_port_trace_syscall_exit(K_SYSCALL_PS2_ENABLE_CALLBACK, ps2_enable_callback, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ps2_disable_callback(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int ps2_disable_callback(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_PS2_DISABLE_CALLBACK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ps2_disable_callback(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ps2_disable_callback(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PS2_DISABLE_CALLBACK, ps2_disable_callback, dev); syscall__retval = ps2_disable_callback(dev); sys_port_trace_syscall_exit(K_SYSCALL_PS2_DISABLE_CALLBACK, ps2_disable_callback, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
133
build/zephyr/include/generated/zephyr/syscalls/psi5.h
Normal file
133
build/zephyr/include/generated/zephyr/syscalls/psi5.h
Normal file
@@ -0,0 +1,133 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_PSI5_H
|
||||
#define Z_INCLUDE_SYSCALLS_PSI5_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_psi5_start_sync(const struct device * dev, uint8_t channel);
|
||||
|
||||
__pinned_func
|
||||
static inline int psi5_start_sync(const struct device * dev, uint8_t channel)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = channel };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PSI5_START_SYNC);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_psi5_start_sync(dev, channel);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define psi5_start_sync(dev, channel) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PSI5_START_SYNC, psi5_start_sync, dev, channel); syscall__retval = psi5_start_sync(dev, channel); sys_port_trace_syscall_exit(K_SYSCALL_PSI5_START_SYNC, psi5_start_sync, dev, channel, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_psi5_stop_sync(const struct device * dev, uint8_t channel);
|
||||
|
||||
__pinned_func
|
||||
static inline int psi5_stop_sync(const struct device * dev, uint8_t channel)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = channel };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PSI5_STOP_SYNC);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_psi5_stop_sync(dev, channel);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define psi5_stop_sync(dev, channel) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PSI5_STOP_SYNC, psi5_stop_sync, dev, channel); syscall__retval = psi5_stop_sync(dev, channel); sys_port_trace_syscall_exit(K_SYSCALL_PSI5_STOP_SYNC, psi5_stop_sync, dev, channel, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_psi5_send(const struct device * dev, uint8_t channel, const uint64_t data, k_timeout_t timeout, psi5_tx_callback_t callback, void * user_data);
|
||||
|
||||
__pinned_func
|
||||
static inline int psi5_send(const struct device * dev, uint8_t channel, const uint64_t data, k_timeout_t timeout, psi5_tx_callback_t callback, void * user_data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = channel };
|
||||
union { uintptr_t x; const uint64_t val; } parm2 = { .val = data };
|
||||
union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm3 = { .val = timeout };
|
||||
union { uintptr_t x; psi5_tx_callback_t val; } parm4 = { .val = callback };
|
||||
union { uintptr_t x; void * val; } parm5 = { .val = user_data };
|
||||
uintptr_t more[] = {
|
||||
parm4.x,
|
||||
parm5.x
|
||||
};
|
||||
return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.split.lo, parm3.split.hi, (uintptr_t) &more, K_SYSCALL_PSI5_SEND);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_psi5_send(dev, channel, data, timeout, callback, user_data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define psi5_send(dev, channel, data, timeout, callback, user_data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PSI5_SEND, psi5_send, dev, channel, data, timeout, callback, user_data); syscall__retval = psi5_send(dev, channel, data, timeout, callback, user_data); sys_port_trace_syscall_exit(K_SYSCALL_PSI5_SEND, psi5_send, dev, channel, data, timeout, callback, user_data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_psi5_register_callback(const struct device * dev, uint8_t channel, struct psi5_rx_callback_configs callback_configs);
|
||||
|
||||
__pinned_func
|
||||
static inline int psi5_register_callback(const struct device * dev, uint8_t channel, struct psi5_rx_callback_configs callback_configs)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = channel };
|
||||
union { uintptr_t x; struct psi5_rx_callback_configs val; } parm2 = { .val = callback_configs };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_PSI5_REGISTER_CALLBACK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_psi5_register_callback(dev, channel, callback_configs);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define psi5_register_callback(dev, channel, callback_configs) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PSI5_REGISTER_CALLBACK, psi5_register_callback, dev, channel, callback_configs); syscall__retval = psi5_register_callback(dev, channel, callback_configs); sys_port_trace_syscall_exit(K_SYSCALL_PSI5_REGISTER_CALLBACK, psi5_register_callback, dev, channel, callback_configs, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
52
build/zephyr/include/generated/zephyr/syscalls/ptp_clock.h
Normal file
52
build/zephyr/include/generated/zephyr/syscalls/ptp_clock.h
Normal file
@@ -0,0 +1,52 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_PTP_CLOCK_H
|
||||
#define Z_INCLUDE_SYSCALLS_PTP_CLOCK_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_ptp_clock_get(const struct device * dev, struct net_ptp_time * tm);
|
||||
|
||||
__pinned_func
|
||||
static inline int ptp_clock_get(const struct device * dev, struct net_ptp_time * tm)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct net_ptp_time * val; } parm1 = { .val = tm };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PTP_CLOCK_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ptp_clock_get(dev, tm);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ptp_clock_get(dev, tm) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PTP_CLOCK_GET, ptp_clock_get, dev, tm); syscall__retval = ptp_clock_get(dev, tm); sys_port_trace_syscall_exit(K_SYSCALL_PTP_CLOCK_GET, ptp_clock_get, dev, tm, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
208
build/zephyr/include/generated/zephyr/syscalls/pwm.h
Normal file
208
build/zephyr/include/generated/zephyr/syscalls/pwm.h
Normal file
@@ -0,0 +1,208 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_PWM_H
|
||||
#define Z_INCLUDE_SYSCALLS_PWM_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_pwm_set_cycles(const struct device * dev, uint32_t channel, uint32_t period, uint32_t pulse, pwm_flags_t flags);
|
||||
|
||||
__pinned_func
|
||||
static inline int pwm_set_cycles(const struct device * dev, uint32_t channel, uint32_t period, uint32_t pulse, pwm_flags_t flags)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = period };
|
||||
union { uintptr_t x; uint32_t val; } parm3 = { .val = pulse };
|
||||
union { uintptr_t x; pwm_flags_t val; } parm4 = { .val = flags };
|
||||
return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_PWM_SET_CYCLES);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_pwm_set_cycles(dev, channel, period, pulse, flags);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define pwm_set_cycles(dev, channel, period, pulse, flags) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PWM_SET_CYCLES, pwm_set_cycles, dev, channel, period, pulse, flags); syscall__retval = pwm_set_cycles(dev, channel, period, pulse, flags); sys_port_trace_syscall_exit(K_SYSCALL_PWM_SET_CYCLES, pwm_set_cycles, dev, channel, period, pulse, flags, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_pwm_get_cycles_per_sec(const struct device * dev, uint32_t channel, uint64_t * cycles);
|
||||
|
||||
__pinned_func
|
||||
static inline int pwm_get_cycles_per_sec(const struct device * dev, uint32_t channel, uint64_t * cycles)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
|
||||
union { uintptr_t x; uint64_t * val; } parm2 = { .val = cycles };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_PWM_GET_CYCLES_PER_SEC);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_pwm_get_cycles_per_sec(dev, channel, cycles);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define pwm_get_cycles_per_sec(dev, channel, cycles) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PWM_GET_CYCLES_PER_SEC, pwm_get_cycles_per_sec, dev, channel, cycles); syscall__retval = pwm_get_cycles_per_sec(dev, channel, cycles); sys_port_trace_syscall_exit(K_SYSCALL_PWM_GET_CYCLES_PER_SEC, pwm_get_cycles_per_sec, dev, channel, cycles, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_pwm_enable_capture(const struct device * dev, uint32_t channel);
|
||||
|
||||
__pinned_func
|
||||
static inline int pwm_enable_capture(const struct device * dev, uint32_t channel)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PWM_ENABLE_CAPTURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_pwm_enable_capture(dev, channel);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define pwm_enable_capture(dev, channel) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PWM_ENABLE_CAPTURE, pwm_enable_capture, dev, channel); syscall__retval = pwm_enable_capture(dev, channel); sys_port_trace_syscall_exit(K_SYSCALL_PWM_ENABLE_CAPTURE, pwm_enable_capture, dev, channel, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_pwm_disable_capture(const struct device * dev, uint32_t channel);
|
||||
|
||||
__pinned_func
|
||||
static inline int pwm_disable_capture(const struct device * dev, uint32_t channel)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PWM_DISABLE_CAPTURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_pwm_disable_capture(dev, channel);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define pwm_disable_capture(dev, channel) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PWM_DISABLE_CAPTURE, pwm_disable_capture, dev, channel); syscall__retval = pwm_disable_capture(dev, channel); sys_port_trace_syscall_exit(K_SYSCALL_PWM_DISABLE_CAPTURE, pwm_disable_capture, dev, channel, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_pwm_enable_dma(const struct device * dev, uint32_t channel);
|
||||
|
||||
__pinned_func
|
||||
static inline int pwm_enable_dma(const struct device * dev, uint32_t channel)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PWM_ENABLE_DMA);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_pwm_enable_dma(dev, channel);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define pwm_enable_dma(dev, channel) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PWM_ENABLE_DMA, pwm_enable_dma, dev, channel); syscall__retval = pwm_enable_dma(dev, channel); sys_port_trace_syscall_exit(K_SYSCALL_PWM_ENABLE_DMA, pwm_enable_dma, dev, channel, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_pwm_disable_dma(const struct device * dev, uint32_t channel);
|
||||
|
||||
__pinned_func
|
||||
static inline int pwm_disable_dma(const struct device * dev, uint32_t channel)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PWM_DISABLE_DMA);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_pwm_disable_dma(dev, channel);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define pwm_disable_dma(dev, channel) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PWM_DISABLE_DMA, pwm_disable_dma, dev, channel); syscall__retval = pwm_disable_dma(dev, channel); sys_port_trace_syscall_exit(K_SYSCALL_PWM_DISABLE_DMA, pwm_disable_dma, dev, channel, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_pwm_capture_cycles(const struct device * dev, uint32_t channel, pwm_flags_t flags, uint32_t * period, uint32_t * pulse, k_timeout_t timeout);
|
||||
|
||||
__pinned_func
|
||||
static inline int pwm_capture_cycles(const struct device * dev, uint32_t channel, pwm_flags_t flags, uint32_t * period, uint32_t * pulse, k_timeout_t timeout)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
|
||||
union { uintptr_t x; pwm_flags_t val; } parm2 = { .val = flags };
|
||||
union { uintptr_t x; uint32_t * val; } parm3 = { .val = period };
|
||||
union { uintptr_t x; uint32_t * val; } parm4 = { .val = pulse };
|
||||
union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm5 = { .val = timeout };
|
||||
uintptr_t more[] = {
|
||||
parm5.split.lo,
|
||||
parm5.split.hi
|
||||
};
|
||||
return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, (uintptr_t) &more, K_SYSCALL_PWM_CAPTURE_CYCLES);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_pwm_capture_cycles(dev, channel, flags, period, pulse, timeout);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define pwm_capture_cycles(dev, channel, flags, period, pulse, timeout) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PWM_CAPTURE_CYCLES, pwm_capture_cycles, dev, channel, flags, period, pulse, timeout); syscall__retval = pwm_capture_cycles(dev, channel, flags, period, pulse, timeout); sys_port_trace_syscall_exit(K_SYSCALL_PWM_CAPTURE_CYCLES, pwm_capture_cycles, dev, channel, flags, period, pulse, timeout, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user