mcuboot starting documentation
This commit is contained in:
Jeremy Janella
@@ -1,9 +0,0 @@
|
||||
/*
|
||||
* 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);
|
||||
@@ -1,38 +0,0 @@
|
||||
/* 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
|
||||
@@ -1,3 +0,0 @@
|
||||
/* SPDX-License-Identifier: Apache-2.0 */
|
||||
|
||||
/* Empty file */
|
||||
@@ -1,3 +0,0 @@
|
||||
/* SPDX-License-Identifier: Apache-2.0 */
|
||||
|
||||
/* Empty file */
|
||||
@@ -1,189 +0,0 @@
|
||||
list(APPEND sections "{NAME\;device_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._flash_driver_api.static.*\;SYMBOLS\;_flash_driver_api_list_start\;_flash_driver_api_list_end\;PRIO\;100}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_flash_driver_api_ext_end\;PRIO\;101}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;102}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_shared_irq_driver_api_ext_end\;PRIO\;103}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._dmic_driver_api.static.*\;SYMBOLS\;_dmic_driver_api_list_start\;_dmic_driver_api_list_end\;PRIO\;104}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_dmic_driver_api_ext_end\;PRIO\;105}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._crypto_driver_api.static.*\;SYMBOLS\;_crypto_driver_api_list_start\;_crypto_driver_api_list_end\;PRIO\;106}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_crypto_driver_api_ext_end\;PRIO\;107}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._adc_driver_api.static.*\;SYMBOLS\;_adc_driver_api_list_start\;_adc_driver_api_list_end\;PRIO\;108}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_adc_driver_api_ext_end\;PRIO\;109}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._auxdisplay_driver_api.static.*\;SYMBOLS\;_auxdisplay_driver_api_list_start\;_auxdisplay_driver_api_list_end\;PRIO\;110}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_auxdisplay_driver_api_ext_end\;PRIO\;111}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._bbram_driver_api.static.*\;SYMBOLS\;_bbram_driver_api_list_start\;_bbram_driver_api_list_end\;PRIO\;112}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_bbram_driver_api_ext_end\;PRIO\;113}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._biometric_driver_api.static.*\;SYMBOLS\;_biometric_driver_api_list_start\;_biometric_driver_api_list_end\;PRIO\;114}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_biometric_driver_api_ext_end\;PRIO\;115}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;116}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_bt_hci_driver_api_ext_end\;PRIO\;117}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._can_driver_api.static.*\;SYMBOLS\;_can_driver_api_list_start\;_can_driver_api_list_end\;PRIO\;118}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_can_driver_api_ext_end\;PRIO\;119}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._cellular_driver_api.static.*\;SYMBOLS\;_cellular_driver_api_list_start\;_cellular_driver_api_list_end\;PRIO\;120}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_cellular_driver_api_ext_end\;PRIO\;121}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._charger_driver_api.static.*\;SYMBOLS\;_charger_driver_api_list_start\;_charger_driver_api_list_end\;PRIO\;122}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_charger_driver_api_ext_end\;PRIO\;123}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;124}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;125}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_nrf_clock_control_driver_api_ext_end\;PRIO\;126}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_clock_control_driver_api_ext_end\;PRIO\;127}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._comparator_driver_api.static.*\;SYMBOLS\;_comparator_driver_api_list_start\;_comparator_driver_api_list_end\;PRIO\;128}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_comparator_driver_api_ext_end\;PRIO\;129}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._coredump_driver_api.static.*\;SYMBOLS\;_coredump_driver_api_list_start\;_coredump_driver_api_list_end\;PRIO\;130}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_coredump_driver_api_ext_end\;PRIO\;131}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._counter_driver_api.static.*\;SYMBOLS\;_counter_driver_api_list_start\;_counter_driver_api_list_end\;PRIO\;132}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_counter_driver_api_ext_end\;PRIO\;133}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._crc_driver_api.static.*\;SYMBOLS\;_crc_driver_api_list_start\;_crc_driver_api_list_end\;PRIO\;134}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_crc_driver_api_ext_end\;PRIO\;135}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._dac_driver_api.static.*\;SYMBOLS\;_dac_driver_api_list_start\;_dac_driver_api_list_end\;PRIO\;136}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_dac_driver_api_ext_end\;PRIO\;137}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._dai_driver_api.static.*\;SYMBOLS\;_dai_driver_api_list_start\;_dai_driver_api_list_end\;PRIO\;138}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_dai_driver_api_ext_end\;PRIO\;139}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._display_driver_api.static.*\;SYMBOLS\;_display_driver_api_list_start\;_display_driver_api_list_end\;PRIO\;140}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_display_driver_api_ext_end\;PRIO\;141}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._dma_driver_api.static.*\;SYMBOLS\;_dma_driver_api_list_start\;_dma_driver_api_list_end\;PRIO\;142}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_dma_driver_api_ext_end\;PRIO\;143}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._edac_driver_api.static.*\;SYMBOLS\;_edac_driver_api_list_start\;_edac_driver_api_list_end\;PRIO\;144}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_edac_driver_api_ext_end\;PRIO\;145}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._eeprom_driver_api.static.*\;SYMBOLS\;_eeprom_driver_api_list_start\;_eeprom_driver_api_list_end\;PRIO\;146}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_eeprom_driver_api_ext_end\;PRIO\;147}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;148}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_emul_bbram_driver_api_ext_end\;PRIO\;149}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;150}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_fuel_gauge_emul_driver_api_ext_end\;PRIO\;151}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;152}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_emul_sensor_driver_api_ext_end\;PRIO\;153}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._entropy_driver_api.static.*\;SYMBOLS\;_entropy_driver_api_list_start\;_entropy_driver_api_list_end\;PRIO\;154}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_entropy_driver_api_ext_end\;PRIO\;155}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._espi_driver_api.static.*\;SYMBOLS\;_espi_driver_api_list_start\;_espi_driver_api_list_end\;PRIO\;156}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_espi_driver_api_ext_end\;PRIO\;157}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;158}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_espi_saf_driver_api_ext_end\;PRIO\;159}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._fpga_driver_api.static.*\;SYMBOLS\;_fpga_driver_api_list_start\;_fpga_driver_api_list_end\;PRIO\;160}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_fpga_driver_api_ext_end\;PRIO\;161}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;162}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_fuel_gauge_driver_api_ext_end\;PRIO\;163}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._gnss_driver_api.static.*\;SYMBOLS\;_gnss_driver_api_list_start\;_gnss_driver_api_list_end\;PRIO\;164}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_gnss_driver_api_ext_end\;PRIO\;165}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._gpio_driver_api.static.*\;SYMBOLS\;_gpio_driver_api_list_start\;_gpio_driver_api_list_end\;PRIO\;166}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_gpio_driver_api_ext_end\;PRIO\;167}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._haptics_driver_api.static.*\;SYMBOLS\;_haptics_driver_api_list_start\;_haptics_driver_api_list_end\;PRIO\;168}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_haptics_driver_api_ext_end\;PRIO\;169}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._hwspinlock_driver_api.static.*\;SYMBOLS\;_hwspinlock_driver_api_list_start\;_hwspinlock_driver_api_list_end\;PRIO\;170}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_hwspinlock_driver_api_ext_end\;PRIO\;171}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._i2c_driver_api.static.*\;SYMBOLS\;_i2c_driver_api_list_start\;_i2c_driver_api_list_end\;PRIO\;172}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._i3c_driver_api.static.*\;SYMBOLS\;_i3c_driver_api_list_start\;_i3c_driver_api_list_end\;PRIO\;173}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_i3c_driver_api_ext_end\;PRIO\;174}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_i2c_driver_api_ext_end\;PRIO\;175}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;176}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_i2c_target_driver_api_ext_end\;PRIO\;177}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._i2s_driver_api.static.*\;SYMBOLS\;_i2s_driver_api_list_start\;_i2s_driver_api_list_end\;PRIO\;178}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_i2s_driver_api_ext_end\;PRIO\;179}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._ipm_driver_api.static.*\;SYMBOLS\;_ipm_driver_api_list_start\;_ipm_driver_api_list_end\;PRIO\;180}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_ipm_driver_api_ext_end\;PRIO\;181}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._led_driver_api.static.*\;SYMBOLS\;_led_driver_api_list_start\;_led_driver_api_list_end\;PRIO\;182}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_led_driver_api_ext_end\;PRIO\;183}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;184}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_led_strip_driver_api_ext_end\;PRIO\;185}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._lora_driver_api.static.*\;SYMBOLS\;_lora_driver_api_list_start\;_lora_driver_api_list_end\;PRIO\;186}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_lora_driver_api_ext_end\;PRIO\;187}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._mbox_driver_api.static.*\;SYMBOLS\;_mbox_driver_api_list_start\;_mbox_driver_api_list_end\;PRIO\;188}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_mbox_driver_api_ext_end\;PRIO\;189}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._mdio_driver_api.static.*\;SYMBOLS\;_mdio_driver_api_list_start\;_mdio_driver_api_list_end\;PRIO\;190}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_mdio_driver_api_ext_end\;PRIO\;191}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;192}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_mipi_dbi_driver_api_ext_end\;PRIO\;193}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;194}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_mipi_dsi_driver_api_ext_end\;PRIO\;195}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._mspi_driver_api.static.*\;SYMBOLS\;_mspi_driver_api_list_start\;_mspi_driver_api_list_end\;PRIO\;196}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_mspi_driver_api_ext_end\;PRIO\;197}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._opamp_driver_api.static.*\;SYMBOLS\;_opamp_driver_api_list_start\;_opamp_driver_api_list_end\;PRIO\;198}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_opamp_driver_api_ext_end\;PRIO\;199}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._otp_driver_api.static.*\;SYMBOLS\;_otp_driver_api_list_start\;_otp_driver_api_list_end\;PRIO\;200}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_otp_driver_api_ext_end\;PRIO\;201}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._peci_driver_api.static.*\;SYMBOLS\;_peci_driver_api_list_start\;_peci_driver_api_list_end\;PRIO\;202}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_peci_driver_api_ext_end\;PRIO\;203}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._ps2_driver_api.static.*\;SYMBOLS\;_ps2_driver_api_list_start\;_ps2_driver_api_list_end\;PRIO\;204}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_ps2_driver_api_ext_end\;PRIO\;205}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;206}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_ptp_clock_driver_api_ext_end\;PRIO\;207}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._pwm_driver_api.static.*\;SYMBOLS\;_pwm_driver_api_list_start\;_pwm_driver_api_list_end\;PRIO\;208}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_pwm_driver_api_ext_end\;PRIO\;209}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;210}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_regulator_parent_driver_api_ext_end\;PRIO\;211}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._regulator_driver_api.static.*\;SYMBOLS\;_regulator_driver_api_list_start\;_regulator_driver_api_list_end\;PRIO\;212}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_regulator_driver_api_ext_end\;PRIO\;213}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._reset_driver_api.static.*\;SYMBOLS\;_reset_driver_api_list_start\;_reset_driver_api_list_end\;PRIO\;214}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_reset_driver_api_ext_end\;PRIO\;215}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;216}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_retained_mem_driver_api_ext_end\;PRIO\;217}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._rtc_driver_api.static.*\;SYMBOLS\;_rtc_driver_api_list_start\;_rtc_driver_api_list_end\;PRIO\;218}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_rtc_driver_api_ext_end\;PRIO\;219}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._sdhc_driver_api.static.*\;SYMBOLS\;_sdhc_driver_api_list_start\;_sdhc_driver_api_list_end\;PRIO\;220}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_sdhc_driver_api_ext_end\;PRIO\;221}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._sensor_driver_api.static.*\;SYMBOLS\;_sensor_driver_api_list_start\;_sensor_driver_api_list_end\;PRIO\;222}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_sensor_driver_api_ext_end\;PRIO\;223}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._smbus_driver_api.static.*\;SYMBOLS\;_smbus_driver_api_list_start\;_smbus_driver_api_list_end\;PRIO\;224}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_smbus_driver_api_ext_end\;PRIO\;225}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._spi_driver_api.static.*\;SYMBOLS\;_spi_driver_api_list_start\;_spi_driver_api_list_end\;PRIO\;226}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_spi_driver_api_ext_end\;PRIO\;227}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._syscon_driver_api.static.*\;SYMBOLS\;_syscon_driver_api_list_start\;_syscon_driver_api_list_end\;PRIO\;228}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_syscon_driver_api_ext_end\;PRIO\;229}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._tee_driver_api.static.*\;SYMBOLS\;_tee_driver_api_list_start\;_tee_driver_api_list_end\;PRIO\;230}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_tee_driver_api_ext_end\;PRIO\;231}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._tgpio_driver_api.static.*\;SYMBOLS\;_tgpio_driver_api_list_start\;_tgpio_driver_api_list_end\;PRIO\;232}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_tgpio_driver_api_ext_end\;PRIO\;233}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._uaol_driver_api.static.*\;SYMBOLS\;_uaol_driver_api_list_start\;_uaol_driver_api_list_end\;PRIO\;234}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_uaol_driver_api_ext_end\;PRIO\;235}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._video_driver_api.static.*\;SYMBOLS\;_video_driver_api_list_start\;_video_driver_api_list_end\;PRIO\;236}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_video_driver_api_ext_end\;PRIO\;237}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._virtio_driver_api.static.*\;SYMBOLS\;_virtio_driver_api_list_start\;_virtio_driver_api_list_end\;PRIO\;238}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_virtio_driver_api_ext_end\;PRIO\;239}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._w1_driver_api.static.*\;SYMBOLS\;_w1_driver_api_list_start\;_w1_driver_api_list_end\;PRIO\;240}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_w1_driver_api_ext_end\;PRIO\;241}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._wdt_driver_api.static.*\;SYMBOLS\;_wdt_driver_api_list_start\;_wdt_driver_api_list_end\;PRIO\;242}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_wdt_driver_api_ext_end\;PRIO\;243}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._wuc_driver_api.static.*\;SYMBOLS\;_wuc_driver_api_list_start\;_wuc_driver_api_list_end\;PRIO\;244}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_wuc_driver_api_ext_end\;PRIO\;245}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;246}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_can_transceiver_driver_api_ext_end\;PRIO\;247}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;248}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_i3c_target_driver_api_ext_end\;PRIO\;249}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._its_driver_api.static.*\;SYMBOLS\;_its_driver_api_list_start\;_its_driver_api_list_end\;PRIO\;250}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_its_driver_api_ext_end\;PRIO\;251}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._vtd_driver_api.static.*\;SYMBOLS\;_vtd_driver_api_list_start\;_vtd_driver_api_list_end\;PRIO\;252}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_vtd_driver_api_ext_end\;PRIO\;253}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;254}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_renesas_elc_driver_api_ext_end\;PRIO\;255}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;256}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_pcie_ctrl_driver_api_ext_end\;PRIO\;257}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;258}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_pcie_ep_driver_api_ext_end\;PRIO\;259}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._psi5_driver_api.static.*\;SYMBOLS\;_psi5_driver_api_list_start\;_psi5_driver_api_list_end\;PRIO\;260}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_psi5_driver_api_ext_end\;PRIO\;261}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._sent_driver_api.static.*\;SYMBOLS\;_sent_driver_api_list_start\;_sent_driver_api_list_end\;PRIO\;262}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_sent_driver_api_ext_end\;PRIO\;263}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._svc_driver_api.static.*\;SYMBOLS\;_svc_driver_api_list_start\;_svc_driver_api_list_end\;PRIO\;264}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_svc_driver_api_ext_end\;PRIO\;265}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._stepper_driver_api.static.*\;SYMBOLS\;_stepper_driver_api_list_start\;_stepper_driver_api_list_end\;PRIO\;266}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_stepper_driver_api_ext_end\;PRIO\;267}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;268}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_stepper_ctrl_driver_api_ext_end\;PRIO\;269}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._uart_driver_api.static.*\;SYMBOLS\;_uart_driver_api_list_start\;_uart_driver_api_list_end\;PRIO\;270}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_uart_driver_api_ext_end\;PRIO\;271}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;272}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_bc12_emul_driver_api_ext_end\;PRIO\;273}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._bc12_driver_api.static.*\;SYMBOLS\;_bc12_driver_api_list_start\;_bc12_driver_api_list_end\;PRIO\;274}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_bc12_driver_api_ext_end\;PRIO\;275}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;276}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_usbc_ppc_driver_api_ext_end\;PRIO\;277}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._tcpc_driver_api.static.*\;SYMBOLS\;_tcpc_driver_api_list_start\;_tcpc_driver_api_list_end\;PRIO\;278}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_tcpc_driver_api_ext_end\;PRIO\;279}")
|
||||
list(APPEND section_settings "{SECTION\;device_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\;PRIO\;280}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_usbc_vbus_driver_api_ext_end\;PRIO\;281}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._ivshmem_driver_api.static.*\;SYMBOLS\;_ivshmem_driver_api_list_start\;_ivshmem_driver_api_list_end\;PRIO\;282}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_ivshmem_driver_api_ext_end\;PRIO\;283}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._ethphy_driver_api.static.*\;SYMBOLS\;_ethphy_driver_api_list_start\;_ethphy_driver_api_list_end\;PRIO\;284}")
|
||||
list(APPEND section_settings "{SECTION\;device_api_area\;SYMBOLS\;_ethphy_driver_api_ext_end\;PRIO\;285}")
|
||||
set(DEVICE_API_SECTIONS "${sections}" CACHE INTERNAL "")
|
||||
set(DEVICE_API_SECTION_SETTINGS "${section_settings}" CACHE INTERNAL "")
|
||||
@@ -1,189 +0,0 @@
|
||||
SECTION_PROLOGUE(device_api_area,,SUBALIGN(4))
|
||||
{
|
||||
Z_LINK_ITERABLE(flash_driver_api);
|
||||
PLACE_SYMBOL_HERE(_flash_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(shared_irq_driver_api);
|
||||
PLACE_SYMBOL_HERE(_shared_irq_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(dmic_driver_api);
|
||||
PLACE_SYMBOL_HERE(_dmic_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(crypto_driver_api);
|
||||
PLACE_SYMBOL_HERE(_crypto_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(adc_driver_api);
|
||||
PLACE_SYMBOL_HERE(_adc_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(auxdisplay_driver_api);
|
||||
PLACE_SYMBOL_HERE(_auxdisplay_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(bbram_driver_api);
|
||||
PLACE_SYMBOL_HERE(_bbram_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(biometric_driver_api);
|
||||
PLACE_SYMBOL_HERE(_biometric_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(bt_hci_driver_api);
|
||||
PLACE_SYMBOL_HERE(_bt_hci_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(can_driver_api);
|
||||
PLACE_SYMBOL_HERE(_can_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(cellular_driver_api);
|
||||
PLACE_SYMBOL_HERE(_cellular_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(charger_driver_api);
|
||||
PLACE_SYMBOL_HERE(_charger_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(clock_control_driver_api);
|
||||
Z_LINK_ITERABLE(nrf_clock_control_driver_api);
|
||||
PLACE_SYMBOL_HERE(_nrf_clock_control_driver_api_ext_end);
|
||||
PLACE_SYMBOL_HERE(_clock_control_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(comparator_driver_api);
|
||||
PLACE_SYMBOL_HERE(_comparator_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(coredump_driver_api);
|
||||
PLACE_SYMBOL_HERE(_coredump_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(counter_driver_api);
|
||||
PLACE_SYMBOL_HERE(_counter_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(crc_driver_api);
|
||||
PLACE_SYMBOL_HERE(_crc_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(dac_driver_api);
|
||||
PLACE_SYMBOL_HERE(_dac_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(dai_driver_api);
|
||||
PLACE_SYMBOL_HERE(_dai_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(display_driver_api);
|
||||
PLACE_SYMBOL_HERE(_display_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(dma_driver_api);
|
||||
PLACE_SYMBOL_HERE(_dma_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(edac_driver_api);
|
||||
PLACE_SYMBOL_HERE(_edac_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(eeprom_driver_api);
|
||||
PLACE_SYMBOL_HERE(_eeprom_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(emul_bbram_driver_api);
|
||||
PLACE_SYMBOL_HERE(_emul_bbram_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(fuel_gauge_emul_driver_api);
|
||||
PLACE_SYMBOL_HERE(_fuel_gauge_emul_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(emul_sensor_driver_api);
|
||||
PLACE_SYMBOL_HERE(_emul_sensor_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(entropy_driver_api);
|
||||
PLACE_SYMBOL_HERE(_entropy_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(espi_driver_api);
|
||||
PLACE_SYMBOL_HERE(_espi_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(espi_saf_driver_api);
|
||||
PLACE_SYMBOL_HERE(_espi_saf_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(fpga_driver_api);
|
||||
PLACE_SYMBOL_HERE(_fpga_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(fuel_gauge_driver_api);
|
||||
PLACE_SYMBOL_HERE(_fuel_gauge_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(gnss_driver_api);
|
||||
PLACE_SYMBOL_HERE(_gnss_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(gpio_driver_api);
|
||||
PLACE_SYMBOL_HERE(_gpio_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(haptics_driver_api);
|
||||
PLACE_SYMBOL_HERE(_haptics_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(hwspinlock_driver_api);
|
||||
PLACE_SYMBOL_HERE(_hwspinlock_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(i2c_driver_api);
|
||||
Z_LINK_ITERABLE(i3c_driver_api);
|
||||
PLACE_SYMBOL_HERE(_i3c_driver_api_ext_end);
|
||||
PLACE_SYMBOL_HERE(_i2c_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(i2c_target_driver_api);
|
||||
PLACE_SYMBOL_HERE(_i2c_target_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(i2s_driver_api);
|
||||
PLACE_SYMBOL_HERE(_i2s_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(ipm_driver_api);
|
||||
PLACE_SYMBOL_HERE(_ipm_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(led_driver_api);
|
||||
PLACE_SYMBOL_HERE(_led_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(led_strip_driver_api);
|
||||
PLACE_SYMBOL_HERE(_led_strip_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(lora_driver_api);
|
||||
PLACE_SYMBOL_HERE(_lora_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(mbox_driver_api);
|
||||
PLACE_SYMBOL_HERE(_mbox_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(mdio_driver_api);
|
||||
PLACE_SYMBOL_HERE(_mdio_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(mipi_dbi_driver_api);
|
||||
PLACE_SYMBOL_HERE(_mipi_dbi_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(mipi_dsi_driver_api);
|
||||
PLACE_SYMBOL_HERE(_mipi_dsi_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(mspi_driver_api);
|
||||
PLACE_SYMBOL_HERE(_mspi_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(opamp_driver_api);
|
||||
PLACE_SYMBOL_HERE(_opamp_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(otp_driver_api);
|
||||
PLACE_SYMBOL_HERE(_otp_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(peci_driver_api);
|
||||
PLACE_SYMBOL_HERE(_peci_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(ps2_driver_api);
|
||||
PLACE_SYMBOL_HERE(_ps2_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(ptp_clock_driver_api);
|
||||
PLACE_SYMBOL_HERE(_ptp_clock_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(pwm_driver_api);
|
||||
PLACE_SYMBOL_HERE(_pwm_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(regulator_parent_driver_api);
|
||||
PLACE_SYMBOL_HERE(_regulator_parent_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(regulator_driver_api);
|
||||
PLACE_SYMBOL_HERE(_regulator_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(reset_driver_api);
|
||||
PLACE_SYMBOL_HERE(_reset_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(retained_mem_driver_api);
|
||||
PLACE_SYMBOL_HERE(_retained_mem_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(rtc_driver_api);
|
||||
PLACE_SYMBOL_HERE(_rtc_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(sdhc_driver_api);
|
||||
PLACE_SYMBOL_HERE(_sdhc_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(sensor_driver_api);
|
||||
PLACE_SYMBOL_HERE(_sensor_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(smbus_driver_api);
|
||||
PLACE_SYMBOL_HERE(_smbus_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(spi_driver_api);
|
||||
PLACE_SYMBOL_HERE(_spi_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(syscon_driver_api);
|
||||
PLACE_SYMBOL_HERE(_syscon_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(tee_driver_api);
|
||||
PLACE_SYMBOL_HERE(_tee_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(tgpio_driver_api);
|
||||
PLACE_SYMBOL_HERE(_tgpio_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(uaol_driver_api);
|
||||
PLACE_SYMBOL_HERE(_uaol_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(video_driver_api);
|
||||
PLACE_SYMBOL_HERE(_video_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(virtio_driver_api);
|
||||
PLACE_SYMBOL_HERE(_virtio_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(w1_driver_api);
|
||||
PLACE_SYMBOL_HERE(_w1_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(wdt_driver_api);
|
||||
PLACE_SYMBOL_HERE(_wdt_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(wuc_driver_api);
|
||||
PLACE_SYMBOL_HERE(_wuc_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(can_transceiver_driver_api);
|
||||
PLACE_SYMBOL_HERE(_can_transceiver_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(i3c_target_driver_api);
|
||||
PLACE_SYMBOL_HERE(_i3c_target_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(its_driver_api);
|
||||
PLACE_SYMBOL_HERE(_its_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(vtd_driver_api);
|
||||
PLACE_SYMBOL_HERE(_vtd_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(renesas_elc_driver_api);
|
||||
PLACE_SYMBOL_HERE(_renesas_elc_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(pcie_ctrl_driver_api);
|
||||
PLACE_SYMBOL_HERE(_pcie_ctrl_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(pcie_ep_driver_api);
|
||||
PLACE_SYMBOL_HERE(_pcie_ep_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(psi5_driver_api);
|
||||
PLACE_SYMBOL_HERE(_psi5_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(sent_driver_api);
|
||||
PLACE_SYMBOL_HERE(_sent_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(svc_driver_api);
|
||||
PLACE_SYMBOL_HERE(_svc_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(stepper_driver_api);
|
||||
PLACE_SYMBOL_HERE(_stepper_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(stepper_ctrl_driver_api);
|
||||
PLACE_SYMBOL_HERE(_stepper_ctrl_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(uart_driver_api);
|
||||
PLACE_SYMBOL_HERE(_uart_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(bc12_emul_driver_api);
|
||||
PLACE_SYMBOL_HERE(_bc12_emul_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(bc12_driver_api);
|
||||
PLACE_SYMBOL_HERE(_bc12_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(usbc_ppc_driver_api);
|
||||
PLACE_SYMBOL_HERE(_usbc_ppc_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(tcpc_driver_api);
|
||||
PLACE_SYMBOL_HERE(_tcpc_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(usbc_vbus_driver_api);
|
||||
PLACE_SYMBOL_HERE(_usbc_vbus_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(ivshmem_driver_api);
|
||||
PLACE_SYMBOL_HERE(_ivshmem_driver_api_ext_end);
|
||||
Z_LINK_ITERABLE(ethphy_driver_api);
|
||||
PLACE_SYMBOL_HERE(_ethphy_driver_api_ext_end);
|
||||
} GROUP_ROM_LINK_IN(RAMABLE_REGION, ROMABLE_REGION)
|
||||
@@ -1 +0,0 @@
|
||||
/* Sort key: "default" */#include "../arch/common/ramfunc.ld"
|
||||
@@ -1 +0,0 @@
|
||||
/* Sort key: "default" */#include "../arch/arm/core/swi_tables.ld"
|
||||
@@ -1,6 +0,0 @@
|
||||
/* Sort key: "!" */#include "../arch/common/rom_start_address.ld"
|
||||
/* Sort key: "$" */#include "../arch/common/fill_with_zeros.ld"
|
||||
/* Sort key: "0x0" */#include "../arch/common/rom_start_offset.ld"
|
||||
/* Sort key: "0x0vectors" */#include "../arch/arm/core/vector_table.ld"
|
||||
/* Sort key: "0x0vectors" */#include "zephyr/linker/irq-vector-table-section.ld"
|
||||
/* Sort key: "0x1vectors" */#include "../arch/arm/core/cortex_m/vector_table_pad.ld"
|
||||
@@ -1 +0,0 @@
|
||||
/* Sort key: "default" */#include "zephyr/linker/intlist.ld"
|
||||
@@ -1,664 +0,0 @@
|
||||
/* 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_FLASH_COPY 5
|
||||
#define K_SYSCALL_FLASH_ERASE 6
|
||||
#define K_SYSCALL_FLASH_EX_OP 7
|
||||
#define K_SYSCALL_FLASH_FILL 8
|
||||
#define K_SYSCALL_FLASH_FLATTEN 9
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_COUNT 10
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX 11
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS 12
|
||||
#define K_SYSCALL_FLASH_GET_PARAMETERS 13
|
||||
#define K_SYSCALL_FLASH_GET_SIZE 14
|
||||
#define K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE 15
|
||||
#define K_SYSCALL_FLASH_READ 16
|
||||
#define K_SYSCALL_FLASH_READ_JEDEC_ID 17
|
||||
#define K_SYSCALL_FLASH_SFDP_READ 18
|
||||
#define K_SYSCALL_FLASH_WRITE 19
|
||||
#define K_SYSCALL_K_BUSY_WAIT 20
|
||||
#define K_SYSCALL_K_CONDVAR_BROADCAST 21
|
||||
#define K_SYSCALL_K_CONDVAR_INIT 22
|
||||
#define K_SYSCALL_K_CONDVAR_SIGNAL 23
|
||||
#define K_SYSCALL_K_CONDVAR_WAIT 24
|
||||
#define K_SYSCALL_K_EVENT_CLEAR 25
|
||||
#define K_SYSCALL_K_EVENT_INIT 26
|
||||
#define K_SYSCALL_K_EVENT_POST 27
|
||||
#define K_SYSCALL_K_EVENT_SET 28
|
||||
#define K_SYSCALL_K_EVENT_SET_MASKED 29
|
||||
#define K_SYSCALL_K_EVENT_WAIT 30
|
||||
#define K_SYSCALL_K_EVENT_WAIT_ALL 31
|
||||
#define K_SYSCALL_K_EVENT_WAIT_ALL_SAFE 32
|
||||
#define K_SYSCALL_K_EVENT_WAIT_SAFE 33
|
||||
#define K_SYSCALL_K_FLOAT_DISABLE 34
|
||||
#define K_SYSCALL_K_FLOAT_ENABLE 35
|
||||
#define K_SYSCALL_K_FUTEX_WAIT 36
|
||||
#define K_SYSCALL_K_FUTEX_WAKE 37
|
||||
#define K_SYSCALL_K_IS_PREEMPT_THREAD 38
|
||||
#define K_SYSCALL_K_MSGQ_ALLOC_INIT 39
|
||||
#define K_SYSCALL_K_MSGQ_GET 40
|
||||
#define K_SYSCALL_K_MSGQ_GET_ATTRS 41
|
||||
#define K_SYSCALL_K_MSGQ_NUM_FREE_GET 42
|
||||
#define K_SYSCALL_K_MSGQ_NUM_USED_GET 43
|
||||
#define K_SYSCALL_K_MSGQ_PEEK 44
|
||||
#define K_SYSCALL_K_MSGQ_PEEK_AT 45
|
||||
#define K_SYSCALL_K_MSGQ_PURGE 46
|
||||
#define K_SYSCALL_K_MSGQ_PUT 47
|
||||
#define K_SYSCALL_K_MSGQ_PUT_FRONT 48
|
||||
#define K_SYSCALL_K_MUTEX_INIT 49
|
||||
#define K_SYSCALL_K_MUTEX_LOCK 50
|
||||
#define K_SYSCALL_K_MUTEX_UNLOCK 51
|
||||
#define K_SYSCALL_K_OBJECT_ACCESS_CHECK 52
|
||||
#define K_SYSCALL_K_OBJECT_ACCESS_GRANT 53
|
||||
#define K_SYSCALL_K_OBJECT_ALLOC 54
|
||||
#define K_SYSCALL_K_OBJECT_ALLOC_SIZE 55
|
||||
#define K_SYSCALL_K_OBJECT_RELEASE 56
|
||||
#define K_SYSCALL_K_PIPE_CLOSE 57
|
||||
#define K_SYSCALL_K_PIPE_INIT 58
|
||||
#define K_SYSCALL_K_PIPE_READ 59
|
||||
#define K_SYSCALL_K_PIPE_RESET 60
|
||||
#define K_SYSCALL_K_PIPE_WRITE 61
|
||||
#define K_SYSCALL_K_POLL 62
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_CHECK 63
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_INIT 64
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_RAISE 65
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_RESET 66
|
||||
#define K_SYSCALL_K_QUEUE_ALLOC_APPEND 67
|
||||
#define K_SYSCALL_K_QUEUE_ALLOC_PREPEND 68
|
||||
#define K_SYSCALL_K_QUEUE_CANCEL_WAIT 69
|
||||
#define K_SYSCALL_K_QUEUE_GET 70
|
||||
#define K_SYSCALL_K_QUEUE_INIT 71
|
||||
#define K_SYSCALL_K_QUEUE_IS_EMPTY 72
|
||||
#define K_SYSCALL_K_QUEUE_PEEK_HEAD 73
|
||||
#define K_SYSCALL_K_QUEUE_PEEK_TAIL 74
|
||||
#define K_SYSCALL_K_RESCHEDULE 75
|
||||
#define K_SYSCALL_K_SCHED_CURRENT_THREAD_QUERY 76
|
||||
#define K_SYSCALL_K_SEM_COUNT_GET 77
|
||||
#define K_SYSCALL_K_SEM_GIVE 78
|
||||
#define K_SYSCALL_K_SEM_INIT 79
|
||||
#define K_SYSCALL_K_SEM_RESET 80
|
||||
#define K_SYSCALL_K_SEM_TAKE 81
|
||||
#define K_SYSCALL_K_SLEEP 82
|
||||
#define K_SYSCALL_K_STACK_ALLOC_INIT 83
|
||||
#define K_SYSCALL_K_STACK_POP 84
|
||||
#define K_SYSCALL_K_STACK_PUSH 85
|
||||
#define K_SYSCALL_K_STR_OUT 86
|
||||
#define K_SYSCALL_K_THREAD_ABORT 87
|
||||
#define K_SYSCALL_K_THREAD_ABSOLUTE_DEADLINE_SET 88
|
||||
#define K_SYSCALL_K_THREAD_CREATE 89
|
||||
#define K_SYSCALL_K_THREAD_CUSTOM_DATA_GET 90
|
||||
#define K_SYSCALL_K_THREAD_CUSTOM_DATA_SET 91
|
||||
#define K_SYSCALL_K_THREAD_DEADLINE_SET 92
|
||||
#define K_SYSCALL_K_THREAD_JOIN 93
|
||||
#define K_SYSCALL_K_THREAD_NAME_COPY 94
|
||||
#define K_SYSCALL_K_THREAD_NAME_SET 95
|
||||
#define K_SYSCALL_K_THREAD_PRIORITY_GET 96
|
||||
#define K_SYSCALL_K_THREAD_PRIORITY_SET 97
|
||||
#define K_SYSCALL_K_THREAD_RESUME 98
|
||||
#define K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_GET 99
|
||||
#define K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_PCT_SET 100
|
||||
#define K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_SET 101
|
||||
#define K_SYSCALL_K_THREAD_STACK_ALLOC 102
|
||||
#define K_SYSCALL_K_THREAD_STACK_FREE 103
|
||||
#define K_SYSCALL_K_THREAD_STACK_SPACE_GET 104
|
||||
#define K_SYSCALL_K_THREAD_SUSPEND 105
|
||||
#define K_SYSCALL_K_THREAD_TIMEOUT_EXPIRES_TICKS 106
|
||||
#define K_SYSCALL_K_THREAD_TIMEOUT_REMAINING_TICKS 107
|
||||
#define K_SYSCALL_K_TIMER_EXPIRES_TICKS 108
|
||||
#define K_SYSCALL_K_TIMER_REMAINING_TICKS 109
|
||||
#define K_SYSCALL_K_TIMER_START 110
|
||||
#define K_SYSCALL_K_TIMER_STATUS_GET 111
|
||||
#define K_SYSCALL_K_TIMER_STATUS_SYNC 112
|
||||
#define K_SYSCALL_K_TIMER_STOP 113
|
||||
#define K_SYSCALL_K_TIMER_USER_DATA_GET 114
|
||||
#define K_SYSCALL_K_TIMER_USER_DATA_SET 115
|
||||
#define K_SYSCALL_K_UPTIME_TICKS 116
|
||||
#define K_SYSCALL_K_USLEEP 117
|
||||
#define K_SYSCALL_K_WAKEUP 118
|
||||
#define K_SYSCALL_K_YIELD 119
|
||||
#define K_SYSCALL_LOG_BUFFERED_CNT 120
|
||||
#define K_SYSCALL_LOG_FILTER_SET 121
|
||||
#define K_SYSCALL_LOG_FRONTEND_FILTER_SET 122
|
||||
#define K_SYSCALL_LOG_PANIC 123
|
||||
#define K_SYSCALL_LOG_PROCESS 124
|
||||
#define K_SYSCALL_SYS_CLOCK_GETRTOFFSET 125
|
||||
#define K_SYSCALL_SYS_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_GET 126
|
||||
#define K_SYSCALL_SYS_CLOCK_NANOSLEEP 127
|
||||
#define K_SYSCALL_SYS_CLOCK_SETTIME 128
|
||||
#define K_SYSCALL_ZEPHYR_FPUTC 129
|
||||
#define K_SYSCALL_ZEPHYR_FWRITE 130
|
||||
#define K_SYSCALL_ZEPHYR_READ_STDIN 131
|
||||
#define K_SYSCALL_ZEPHYR_WRITE_STDOUT 132
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0 133
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1 134
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2 135
|
||||
#define K_SYSCALL_Z_LOG_MSG_STATIC_CREATE 136
|
||||
#define K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK 137
|
||||
#define K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK 138
|
||||
#define K_SYSCALL_BAD 139
|
||||
#define K_SYSCALL_LIMIT 140
|
||||
|
||||
|
||||
/* Following syscalls are not used in image */
|
||||
#define K_SYSCALL_ADC_CHANNEL_SETUP 141
|
||||
#define K_SYSCALL_ADC_GET_DECODER 142
|
||||
#define K_SYSCALL_ADC_READ 143
|
||||
#define K_SYSCALL_ADC_READ_ASYNC 144
|
||||
#define K_SYSCALL_ATOMIC_ADD 145
|
||||
#define K_SYSCALL_ATOMIC_AND 146
|
||||
#define K_SYSCALL_ATOMIC_CAS 147
|
||||
#define K_SYSCALL_ATOMIC_NAND 148
|
||||
#define K_SYSCALL_ATOMIC_OR 149
|
||||
#define K_SYSCALL_ATOMIC_PTR_CAS 150
|
||||
#define K_SYSCALL_ATOMIC_PTR_SET 151
|
||||
#define K_SYSCALL_ATOMIC_SET 152
|
||||
#define K_SYSCALL_ATOMIC_SUB 153
|
||||
#define K_SYSCALL_ATOMIC_XOR 154
|
||||
#define K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET 155
|
||||
#define K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET 156
|
||||
#define K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET 157
|
||||
#define K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET 158
|
||||
#define K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET 159
|
||||
#define K_SYSCALL_AUXDISPLAY_CLEAR 160
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET 161
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET 162
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED 163
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET 164
|
||||
#define K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET 165
|
||||
#define K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND 166
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_OFF 167
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_ON 168
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET 169
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET 170
|
||||
#define K_SYSCALL_AUXDISPLAY_IS_BUSY 171
|
||||
#define K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED 172
|
||||
#define K_SYSCALL_AUXDISPLAY_WRITE 173
|
||||
#define K_SYSCALL_BBRAM_CHECK_INVALID 174
|
||||
#define K_SYSCALL_BBRAM_CHECK_POWER 175
|
||||
#define K_SYSCALL_BBRAM_CHECK_STANDBY_POWER 176
|
||||
#define K_SYSCALL_BBRAM_GET_SIZE 177
|
||||
#define K_SYSCALL_BBRAM_READ 178
|
||||
#define K_SYSCALL_BBRAM_WRITE 179
|
||||
#define K_SYSCALL_BC12_SET_RESULT_CB 180
|
||||
#define K_SYSCALL_BC12_SET_ROLE 181
|
||||
#define K_SYSCALL_BIOMETRIC_ATTR_GET 182
|
||||
#define K_SYSCALL_BIOMETRIC_ATTR_SET 183
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_ABORT 184
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_CAPTURE 185
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_FINALIZE 186
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_START 187
|
||||
#define K_SYSCALL_BIOMETRIC_GET_CAPABILITIES 188
|
||||
#define K_SYSCALL_BIOMETRIC_LED_CONTROL 189
|
||||
#define K_SYSCALL_BIOMETRIC_MATCH 190
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_DELETE 191
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_DELETE_ALL 192
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_LIST 193
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_READ 194
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_STORE 195
|
||||
#define K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ 196
|
||||
#define K_SYSCALL_CAN_CALC_TIMING 197
|
||||
#define K_SYSCALL_CAN_CALC_TIMING_DATA 198
|
||||
#define K_SYSCALL_CAN_GET_BITRATE_MAX 199
|
||||
#define K_SYSCALL_CAN_GET_BITRATE_MIN 200
|
||||
#define K_SYSCALL_CAN_GET_CAPABILITIES 201
|
||||
#define K_SYSCALL_CAN_GET_CORE_CLOCK 202
|
||||
#define K_SYSCALL_CAN_GET_MAX_FILTERS 203
|
||||
#define K_SYSCALL_CAN_GET_MODE 204
|
||||
#define K_SYSCALL_CAN_GET_STATE 205
|
||||
#define K_SYSCALL_CAN_GET_TIMING_DATA_MAX 206
|
||||
#define K_SYSCALL_CAN_GET_TIMING_DATA_MIN 207
|
||||
#define K_SYSCALL_CAN_GET_TIMING_MAX 208
|
||||
#define K_SYSCALL_CAN_GET_TIMING_MIN 209
|
||||
#define K_SYSCALL_CAN_GET_TRANSCEIVER 210
|
||||
#define K_SYSCALL_CAN_RECOVER 211
|
||||
#define K_SYSCALL_CAN_REMOVE_RX_FILTER 212
|
||||
#define K_SYSCALL_CAN_SEND 213
|
||||
#define K_SYSCALL_CAN_SET_BITRATE 214
|
||||
#define K_SYSCALL_CAN_SET_BITRATE_DATA 215
|
||||
#define K_SYSCALL_CAN_SET_MODE 216
|
||||
#define K_SYSCALL_CAN_SET_TIMING 217
|
||||
#define K_SYSCALL_CAN_SET_TIMING_DATA 218
|
||||
#define K_SYSCALL_CAN_START 219
|
||||
#define K_SYSCALL_CAN_STATS_GET_ACK_ERRORS 220
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS 221
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS 222
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT_ERRORS 223
|
||||
#define K_SYSCALL_CAN_STATS_GET_CRC_ERRORS 224
|
||||
#define K_SYSCALL_CAN_STATS_GET_FORM_ERRORS 225
|
||||
#define K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS 226
|
||||
#define K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS 227
|
||||
#define K_SYSCALL_CAN_STOP 228
|
||||
#define K_SYSCALL_CHARGER_CHARGE_ENABLE 229
|
||||
#define K_SYSCALL_CHARGER_GET_PROP 230
|
||||
#define K_SYSCALL_CHARGER_SET_PROP 231
|
||||
#define K_SYSCALL_COMPARATOR_GET_OUTPUT 232
|
||||
#define K_SYSCALL_COMPARATOR_SET_TRIGGER 233
|
||||
#define K_SYSCALL_COMPARATOR_TRIGGER_IS_PENDING 234
|
||||
#define K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM 235
|
||||
#define K_SYSCALL_COUNTER_DISABLE_CAPTURE 236
|
||||
#define K_SYSCALL_COUNTER_ENABLE_CAPTURE 237
|
||||
#define K_SYSCALL_COUNTER_GET_FREQUENCY 238
|
||||
#define K_SYSCALL_COUNTER_GET_FREQUENCY_64 239
|
||||
#define K_SYSCALL_COUNTER_GET_GUARD_PERIOD 240
|
||||
#define K_SYSCALL_COUNTER_GET_GUARD_PERIOD_64 241
|
||||
#define K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE 242
|
||||
#define K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE_64 243
|
||||
#define K_SYSCALL_COUNTER_GET_NUM_OF_CHANNELS 244
|
||||
#define K_SYSCALL_COUNTER_GET_PENDING_INT 245
|
||||
#define K_SYSCALL_COUNTER_GET_TOP_VALUE 246
|
||||
#define K_SYSCALL_COUNTER_GET_TOP_VALUE_64 247
|
||||
#define K_SYSCALL_COUNTER_GET_VALUE 248
|
||||
#define K_SYSCALL_COUNTER_GET_VALUE_64 249
|
||||
#define K_SYSCALL_COUNTER_IS_COUNTING_UP 250
|
||||
#define K_SYSCALL_COUNTER_NS_TO_TICKS 251
|
||||
#define K_SYSCALL_COUNTER_NS_TO_TICKS_64 252
|
||||
#define K_SYSCALL_COUNTER_RESET 253
|
||||
#define K_SYSCALL_COUNTER_SET_CHANNEL_ALARM 254
|
||||
#define K_SYSCALL_COUNTER_SET_CHANNEL_ALARM_64 255
|
||||
#define K_SYSCALL_COUNTER_SET_GUARD_PERIOD 256
|
||||
#define K_SYSCALL_COUNTER_SET_GUARD_PERIOD_64 257
|
||||
#define K_SYSCALL_COUNTER_SET_TOP_VALUE 258
|
||||
#define K_SYSCALL_COUNTER_SET_TOP_VALUE_64 259
|
||||
#define K_SYSCALL_COUNTER_SET_VALUE 260
|
||||
#define K_SYSCALL_COUNTER_SET_VALUE_64 261
|
||||
#define K_SYSCALL_COUNTER_START 262
|
||||
#define K_SYSCALL_COUNTER_STOP 263
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_NS 264
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_NS_64 265
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_US 266
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_US_64 267
|
||||
#define K_SYSCALL_COUNTER_US_TO_TICKS 268
|
||||
#define K_SYSCALL_COUNTER_US_TO_TICKS_64 269
|
||||
#define K_SYSCALL_CRC_BEGIN 270
|
||||
#define K_SYSCALL_CRC_FINISH 271
|
||||
#define K_SYSCALL_CRC_UPDATE 272
|
||||
#define K_SYSCALL_DAC_CHANNEL_SETUP 273
|
||||
#define K_SYSCALL_DAC_WRITE_VALUE 274
|
||||
#define K_SYSCALL_DAI_CONFIG_GET 275
|
||||
#define K_SYSCALL_DAI_CONFIG_SET 276
|
||||
#define K_SYSCALL_DAI_CONFIG_UPDATE 277
|
||||
#define K_SYSCALL_DAI_GET_PROPERTIES_COPY 278
|
||||
#define K_SYSCALL_DAI_PROBE 279
|
||||
#define K_SYSCALL_DAI_REMOVE 280
|
||||
#define K_SYSCALL_DAI_TRIGGER 281
|
||||
#define K_SYSCALL_DAI_TS_CONFIG 282
|
||||
#define K_SYSCALL_DAI_TS_GET 283
|
||||
#define K_SYSCALL_DAI_TS_START 284
|
||||
#define K_SYSCALL_DAI_TS_STOP 285
|
||||
#define K_SYSCALL_DEVMUX_SELECT_GET 286
|
||||
#define K_SYSCALL_DEVMUX_SELECT_SET 287
|
||||
#define K_SYSCALL_EEPROM_GET_SIZE 288
|
||||
#define K_SYSCALL_EEPROM_READ 289
|
||||
#define K_SYSCALL_EEPROM_WRITE 290
|
||||
#define K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF 291
|
||||
#define K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING 292
|
||||
#define K_SYSCALL_ENTROPY_GET_ENTROPY 293
|
||||
#define K_SYSCALL_ESPI_CONFIG 294
|
||||
#define K_SYSCALL_ESPI_FLASH_ERASE 295
|
||||
#define K_SYSCALL_ESPI_GET_CHANNEL_STATUS 296
|
||||
#define K_SYSCALL_ESPI_READ_FLASH 297
|
||||
#define K_SYSCALL_ESPI_READ_LPC_REQUEST 298
|
||||
#define K_SYSCALL_ESPI_READ_REQUEST 299
|
||||
#define K_SYSCALL_ESPI_RECEIVE_OOB 300
|
||||
#define K_SYSCALL_ESPI_RECEIVE_VWIRE 301
|
||||
#define K_SYSCALL_ESPI_SAF_ACTIVATE 302
|
||||
#define K_SYSCALL_ESPI_SAF_CONFIG 303
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_ERASE 304
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_READ 305
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS 306
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_WRITE 307
|
||||
#define K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS 308
|
||||
#define K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS 309
|
||||
#define K_SYSCALL_ESPI_SEND_OOB 310
|
||||
#define K_SYSCALL_ESPI_SEND_VWIRE 311
|
||||
#define K_SYSCALL_ESPI_WRITE_FLASH 312
|
||||
#define K_SYSCALL_ESPI_WRITE_LPC_REQUEST 313
|
||||
#define K_SYSCALL_ESPI_WRITE_REQUEST 314
|
||||
#define K_SYSCALL_FLASH_SIMULATOR_GET_MEMORY 315
|
||||
#define K_SYSCALL_FLASH_SIMULATOR_GET_PARAMS 316
|
||||
#define K_SYSCALL_FLASH_SIMULATOR_SET_CALLBACKS 317
|
||||
#define K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF 318
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP 319
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_PROP 320
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_PROPS 321
|
||||
#define K_SYSCALL_FUEL_GAUGE_SET_PROP 322
|
||||
#define K_SYSCALL_FUEL_GAUGE_SET_PROPS 323
|
||||
#define K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS 324
|
||||
#define K_SYSCALL_GNSS_GET_FIX_RATE 325
|
||||
#define K_SYSCALL_GNSS_GET_LATEST_TIMEPULSE 326
|
||||
#define K_SYSCALL_GNSS_GET_NAVIGATION_MODE 327
|
||||
#define K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS 328
|
||||
#define K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS 329
|
||||
#define K_SYSCALL_GNSS_SET_FIX_RATE 330
|
||||
#define K_SYSCALL_GNSS_SET_NAVIGATION_MODE 331
|
||||
#define K_SYSCALL_GPIO_GET_PENDING_INT 332
|
||||
#define K_SYSCALL_GPIO_PIN_CONFIGURE 333
|
||||
#define K_SYSCALL_GPIO_PIN_GET_CONFIG 334
|
||||
#define K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE 335
|
||||
#define K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW 336
|
||||
#define K_SYSCALL_GPIO_PORT_GET_DIRECTION 337
|
||||
#define K_SYSCALL_GPIO_PORT_GET_RAW 338
|
||||
#define K_SYSCALL_GPIO_PORT_SET_BITS_RAW 339
|
||||
#define K_SYSCALL_GPIO_PORT_SET_MASKED_RAW 340
|
||||
#define K_SYSCALL_GPIO_PORT_TOGGLE_BITS 341
|
||||
#define K_SYSCALL_HAPTICS_START_OUTPUT 342
|
||||
#define K_SYSCALL_HAPTICS_STOP_OUTPUT 343
|
||||
#define K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE 344
|
||||
#define K_SYSCALL_HWINFO_GET_DEVICE_EUI64 345
|
||||
#define K_SYSCALL_HWINFO_GET_DEVICE_ID 346
|
||||
#define K_SYSCALL_HWINFO_GET_RESET_CAUSE 347
|
||||
#define K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE 348
|
||||
#define K_SYSCALL_I2C_CONFIGURE 349
|
||||
#define K_SYSCALL_I2C_GET_CONFIG 350
|
||||
#define K_SYSCALL_I2C_RECOVER_BUS 351
|
||||
#define K_SYSCALL_I2C_TARGET_DRIVER_REGISTER 352
|
||||
#define K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER 353
|
||||
#define K_SYSCALL_I2C_TRANSFER 354
|
||||
#define K_SYSCALL_I2S_BUF_READ 355
|
||||
#define K_SYSCALL_I2S_BUF_WRITE 356
|
||||
#define K_SYSCALL_I2S_CONFIGURE 357
|
||||
#define K_SYSCALL_I2S_TRIGGER 358
|
||||
#define K_SYSCALL_I3C_DO_CCC 359
|
||||
#define K_SYSCALL_I3C_DO_CCC_CB 360
|
||||
#define K_SYSCALL_I3C_TRANSFER 361
|
||||
#define K_SYSCALL_I3C_TRANSFER_CB 362
|
||||
#define K_SYSCALL_IPM_COMPLETE 363
|
||||
#define K_SYSCALL_IPM_MAX_DATA_SIZE_GET 364
|
||||
#define K_SYSCALL_IPM_MAX_ID_VAL_GET 365
|
||||
#define K_SYSCALL_IPM_SEND 366
|
||||
#define K_SYSCALL_IPM_SET_ENABLED 367
|
||||
#define K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS 368
|
||||
#define K_SYSCALL_IVSHMEM_GET_ID 369
|
||||
#define K_SYSCALL_IVSHMEM_GET_MAX_PEERS 370
|
||||
#define K_SYSCALL_IVSHMEM_GET_MEM 371
|
||||
#define K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION 372
|
||||
#define K_SYSCALL_IVSHMEM_GET_PROTOCOL 373
|
||||
#define K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION 374
|
||||
#define K_SYSCALL_IVSHMEM_GET_STATE 375
|
||||
#define K_SYSCALL_IVSHMEM_GET_VECTORS 376
|
||||
#define K_SYSCALL_IVSHMEM_INT_PEER 377
|
||||
#define K_SYSCALL_IVSHMEM_REGISTER_HANDLER 378
|
||||
#define K_SYSCALL_IVSHMEM_SET_STATE 379
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET 380
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET 381
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET 382
|
||||
#define K_SYSCALL_K_MEM_PAGING_STATS_GET 383
|
||||
#define K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET 384
|
||||
#define K_SYSCALL_LED_BLINK 385
|
||||
#define K_SYSCALL_LED_GET_INFO 386
|
||||
#define K_SYSCALL_LED_OFF 387
|
||||
#define K_SYSCALL_LED_ON 388
|
||||
#define K_SYSCALL_LED_SET_BRIGHTNESS 389
|
||||
#define K_SYSCALL_LED_SET_CHANNEL 390
|
||||
#define K_SYSCALL_LED_SET_COLOR 391
|
||||
#define K_SYSCALL_LED_WRITE_CHANNELS 392
|
||||
#define K_SYSCALL_LLEXT_GET_FN_TABLE 393
|
||||
#define K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT 394
|
||||
#define K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT 395
|
||||
#define K_SYSCALL_MBOX_MAX_CHANNELS_GET 396
|
||||
#define K_SYSCALL_MBOX_MTU_GET 397
|
||||
#define K_SYSCALL_MBOX_SEND 398
|
||||
#define K_SYSCALL_MBOX_SET_ENABLED 399
|
||||
#define K_SYSCALL_MDIO_READ 400
|
||||
#define K_SYSCALL_MDIO_READ_C45 401
|
||||
#define K_SYSCALL_MDIO_WRITE 402
|
||||
#define K_SYSCALL_MDIO_WRITE_C45 403
|
||||
#define K_SYSCALL_MSPI_CONFIG 404
|
||||
#define K_SYSCALL_MSPI_DEV_CONFIG 405
|
||||
#define K_SYSCALL_MSPI_GET_CHANNEL_STATUS 406
|
||||
#define K_SYSCALL_MSPI_SCRAMBLE_CONFIG 407
|
||||
#define K_SYSCALL_MSPI_TIMING_CONFIG 408
|
||||
#define K_SYSCALL_MSPI_TRANSCEIVE 409
|
||||
#define K_SYSCALL_MSPI_XIP_CONFIG 410
|
||||
#define K_SYSCALL_NET_ADDR_NTOP 411
|
||||
#define K_SYSCALL_NET_ADDR_PTON 412
|
||||
#define K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX 413
|
||||
#define K_SYSCALL_NET_IF_GET_BY_INDEX 414
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_ADD_BY_INDEX 415
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_LOOKUP_BY_INDEX 416
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX 417
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_GW_BY_INDEX 418
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_ADDR_BY_INDEX 419
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_ADD_BY_INDEX 420
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_LOOKUP_BY_INDEX 421
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_RM_BY_INDEX 422
|
||||
#define K_SYSCALL_NET_SOCKET_SERVICE_REGISTER 423
|
||||
#define K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE 424
|
||||
#define K_SYSCALL_OPAMP_SET_GAIN 425
|
||||
#define K_SYSCALL_OTP_PROGRAM 426
|
||||
#define K_SYSCALL_OTP_READ 427
|
||||
#define K_SYSCALL_PECI_CONFIG 428
|
||||
#define K_SYSCALL_PECI_DISABLE 429
|
||||
#define K_SYSCALL_PECI_ENABLE 430
|
||||
#define K_SYSCALL_PECI_TRANSFER 431
|
||||
#define K_SYSCALL_PS2_CONFIG 432
|
||||
#define K_SYSCALL_PS2_DISABLE_CALLBACK 433
|
||||
#define K_SYSCALL_PS2_ENABLE_CALLBACK 434
|
||||
#define K_SYSCALL_PS2_READ 435
|
||||
#define K_SYSCALL_PS2_WRITE 436
|
||||
#define K_SYSCALL_PSI5_REGISTER_CALLBACK 437
|
||||
#define K_SYSCALL_PSI5_SEND 438
|
||||
#define K_SYSCALL_PSI5_START_SYNC 439
|
||||
#define K_SYSCALL_PSI5_STOP_SYNC 440
|
||||
#define K_SYSCALL_PTP_CLOCK_GET 441
|
||||
#define K_SYSCALL_PWM_CAPTURE_CYCLES 442
|
||||
#define K_SYSCALL_PWM_DISABLE_CAPTURE 443
|
||||
#define K_SYSCALL_PWM_ENABLE_CAPTURE 444
|
||||
#define K_SYSCALL_PWM_GET_CYCLES_PER_SEC 445
|
||||
#define K_SYSCALL_PWM_SET_CYCLES 446
|
||||
#define K_SYSCALL_RENESAS_ELC_DISABLE 447
|
||||
#define K_SYSCALL_RENESAS_ELC_ENABLE 448
|
||||
#define K_SYSCALL_RENESAS_ELC_LINK_BREAK 449
|
||||
#define K_SYSCALL_RENESAS_ELC_LINK_SET 450
|
||||
#define K_SYSCALL_RENESAS_ELC_SOFTWARE_EVENT_GENERATE 451
|
||||
#define K_SYSCALL_RENESAS_RA_CTSU_GROUP_CONFIGURE 452
|
||||
#define K_SYSCALL_RENESAS_RX_CTSU_GROUP_CONFIGURE 453
|
||||
#define K_SYSCALL_RESET_LINE_ASSERT 454
|
||||
#define K_SYSCALL_RESET_LINE_DEASSERT 455
|
||||
#define K_SYSCALL_RESET_LINE_TOGGLE 456
|
||||
#define K_SYSCALL_RESET_STATUS 457
|
||||
#define K_SYSCALL_RETAINED_MEM_CLEAR 458
|
||||
#define K_SYSCALL_RETAINED_MEM_READ 459
|
||||
#define K_SYSCALL_RETAINED_MEM_SIZE 460
|
||||
#define K_SYSCALL_RETAINED_MEM_WRITE 461
|
||||
#define K_SYSCALL_RTC_ALARM_GET_SUPPORTED_FIELDS 462
|
||||
#define K_SYSCALL_RTC_ALARM_GET_TIME 463
|
||||
#define K_SYSCALL_RTC_ALARM_IS_PENDING 464
|
||||
#define K_SYSCALL_RTC_ALARM_SET_TIME 465
|
||||
#define K_SYSCALL_RTC_GET_CALIBRATION 466
|
||||
#define K_SYSCALL_RTC_GET_TIME 467
|
||||
#define K_SYSCALL_RTC_SET_CALIBRATION 468
|
||||
#define K_SYSCALL_RTC_SET_TIME 469
|
||||
#define K_SYSCALL_RTIO_CQE_COPY_OUT 470
|
||||
#define K_SYSCALL_RTIO_CQE_GET_MEMPOOL_BUFFER 471
|
||||
#define K_SYSCALL_RTIO_POOL_ACQUIRE 472
|
||||
#define K_SYSCALL_RTIO_POOL_RELEASE 473
|
||||
#define K_SYSCALL_RTIO_RELEASE_BUFFER 474
|
||||
#define K_SYSCALL_RTIO_SQE_CANCEL 475
|
||||
#define K_SYSCALL_RTIO_SQE_COPY_IN_GET_HANDLES 476
|
||||
#define K_SYSCALL_RTIO_SQE_SIGNAL 477
|
||||
#define K_SYSCALL_RTIO_SUBMIT 478
|
||||
#define K_SYSCALL_SDHC_CARD_BUSY 479
|
||||
#define K_SYSCALL_SDHC_CARD_PRESENT 480
|
||||
#define K_SYSCALL_SDHC_DISABLE_INTERRUPT 481
|
||||
#define K_SYSCALL_SDHC_ENABLE_INTERRUPT 482
|
||||
#define K_SYSCALL_SDHC_EXECUTE_TUNING 483
|
||||
#define K_SYSCALL_SDHC_GET_HOST_PROPS 484
|
||||
#define K_SYSCALL_SDHC_HW_RESET 485
|
||||
#define K_SYSCALL_SDHC_REQUEST 486
|
||||
#define K_SYSCALL_SDHC_SET_IO 487
|
||||
#define K_SYSCALL_SENSOR_ATTR_GET 488
|
||||
#define K_SYSCALL_SENSOR_ATTR_SET 489
|
||||
#define K_SYSCALL_SENSOR_CHANNEL_GET 490
|
||||
#define K_SYSCALL_SENSOR_GET_DECODER 491
|
||||
#define K_SYSCALL_SENSOR_RECONFIGURE_READ_IODEV 492
|
||||
#define K_SYSCALL_SENSOR_SAMPLE_FETCH 493
|
||||
#define K_SYSCALL_SENSOR_SAMPLE_FETCH_CHAN 494
|
||||
#define K_SYSCALL_SENT_REGISTER_CALLBACK 495
|
||||
#define K_SYSCALL_SENT_START_LISTENING 496
|
||||
#define K_SYSCALL_SENT_STOP_LISTENING 497
|
||||
#define K_SYSCALL_SIP_SUPERVISORY_CALL 498
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_REQ 499
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_RES 500
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FORMAT_TRANS_ID 501
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FREE_ASYNC_MEMORY 502
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FUNC_ID_VALID 503
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_GET_ERROR_CODE 504
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_GET_TRANS_IDX 505
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_UPDATE_TRANS_ID 506
|
||||
#define K_SYSCALL_SMBUS_BLOCK_PCALL 507
|
||||
#define K_SYSCALL_SMBUS_BLOCK_READ 508
|
||||
#define K_SYSCALL_SMBUS_BLOCK_WRITE 509
|
||||
#define K_SYSCALL_SMBUS_BYTE_DATA_READ 510
|
||||
#define K_SYSCALL_SMBUS_BYTE_DATA_WRITE 511
|
||||
#define K_SYSCALL_SMBUS_BYTE_READ 512
|
||||
#define K_SYSCALL_SMBUS_BYTE_WRITE 513
|
||||
#define K_SYSCALL_SMBUS_CONFIGURE 514
|
||||
#define K_SYSCALL_SMBUS_GET_CONFIG 515
|
||||
#define K_SYSCALL_SMBUS_HOST_NOTIFY_REMOVE_CB 516
|
||||
#define K_SYSCALL_SMBUS_PCALL 517
|
||||
#define K_SYSCALL_SMBUS_QUICK 518
|
||||
#define K_SYSCALL_SMBUS_SMBALERT_REMOVE_CB 519
|
||||
#define K_SYSCALL_SMBUS_WORD_DATA_READ 520
|
||||
#define K_SYSCALL_SMBUS_WORD_DATA_WRITE 521
|
||||
#define K_SYSCALL_SPI_RELEASE 522
|
||||
#define K_SYSCALL_SPI_TRANSCEIVE 523
|
||||
#define K_SYSCALL_STEPPER_CTRL_CONFIGURE_RAMP 524
|
||||
#define K_SYSCALL_STEPPER_CTRL_GET_ACTUAL_POSITION 525
|
||||
#define K_SYSCALL_STEPPER_CTRL_IS_MOVING 526
|
||||
#define K_SYSCALL_STEPPER_CTRL_MOVE_BY 527
|
||||
#define K_SYSCALL_STEPPER_CTRL_MOVE_TO 528
|
||||
#define K_SYSCALL_STEPPER_CTRL_RUN 529
|
||||
#define K_SYSCALL_STEPPER_CTRL_SET_EVENT_CB 530
|
||||
#define K_SYSCALL_STEPPER_CTRL_SET_MICROSTEP_INTERVAL 531
|
||||
#define K_SYSCALL_STEPPER_CTRL_SET_REFERENCE_POSITION 532
|
||||
#define K_SYSCALL_STEPPER_CTRL_STOP 533
|
||||
#define K_SYSCALL_STEPPER_DISABLE 534
|
||||
#define K_SYSCALL_STEPPER_ENABLE 535
|
||||
#define K_SYSCALL_STEPPER_GET_MICRO_STEP_RES 536
|
||||
#define K_SYSCALL_STEPPER_SET_EVENT_CB 537
|
||||
#define K_SYSCALL_STEPPER_SET_MICRO_STEP_RES 538
|
||||
#define K_SYSCALL_SWDP_CONFIGURE 539
|
||||
#define K_SYSCALL_SWDP_GET_PINS 540
|
||||
#define K_SYSCALL_SWDP_INPUT_SEQUENCE 541
|
||||
#define K_SYSCALL_SWDP_OUTPUT_SEQUENCE 542
|
||||
#define K_SYSCALL_SWDP_PORT_OFF 543
|
||||
#define K_SYSCALL_SWDP_PORT_ON 544
|
||||
#define K_SYSCALL_SWDP_SET_CLOCK 545
|
||||
#define K_SYSCALL_SWDP_SET_PINS 546
|
||||
#define K_SYSCALL_SWDP_TRANSFER 547
|
||||
#define K_SYSCALL_SYSCON_GET_BASE 548
|
||||
#define K_SYSCALL_SYSCON_GET_SIZE 549
|
||||
#define K_SYSCALL_SYSCON_READ_REG 550
|
||||
#define K_SYSCALL_SYSCON_UPDATE_BITS 551
|
||||
#define K_SYSCALL_SYSCON_WRITE_REG 552
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE 553
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE 554
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE 555
|
||||
#define K_SYSCALL_SYS_CSRAND_GET 556
|
||||
#define K_SYSCALL_SYS_RAND_GET 557
|
||||
#define K_SYSCALL_TEE_CANCEL 558
|
||||
#define K_SYSCALL_TEE_CLOSE_SESSION 559
|
||||
#define K_SYSCALL_TEE_GET_VERSION 560
|
||||
#define K_SYSCALL_TEE_INVOKE_FUNC 561
|
||||
#define K_SYSCALL_TEE_OPEN_SESSION 562
|
||||
#define K_SYSCALL_TEE_SHM_ALLOC 563
|
||||
#define K_SYSCALL_TEE_SHM_FREE 564
|
||||
#define K_SYSCALL_TEE_SHM_REGISTER 565
|
||||
#define K_SYSCALL_TEE_SHM_UNREGISTER 566
|
||||
#define K_SYSCALL_TEE_SUPPL_RECV 567
|
||||
#define K_SYSCALL_TEE_SUPPL_SEND 568
|
||||
#define K_SYSCALL_TGPIO_PIN_CONFIG_EXT_TIMESTAMP 569
|
||||
#define K_SYSCALL_TGPIO_PIN_DISABLE 570
|
||||
#define K_SYSCALL_TGPIO_PIN_PERIODIC_OUTPUT 571
|
||||
#define K_SYSCALL_TGPIO_PIN_READ_TS_EC 572
|
||||
#define K_SYSCALL_TGPIO_PORT_GET_CYCLES_PER_SECOND 573
|
||||
#define K_SYSCALL_TGPIO_PORT_GET_TIME 574
|
||||
#define K_SYSCALL_UART_CONFIGURE 575
|
||||
#define K_SYSCALL_UART_CONFIG_GET 576
|
||||
#define K_SYSCALL_UART_DRV_CMD 577
|
||||
#define K_SYSCALL_UART_ERR_CHECK 578
|
||||
#define K_SYSCALL_UART_IRQ_ERR_DISABLE 579
|
||||
#define K_SYSCALL_UART_IRQ_ERR_ENABLE 580
|
||||
#define K_SYSCALL_UART_IRQ_IS_PENDING 581
|
||||
#define K_SYSCALL_UART_IRQ_RX_DISABLE 582
|
||||
#define K_SYSCALL_UART_IRQ_RX_ENABLE 583
|
||||
#define K_SYSCALL_UART_IRQ_TX_DISABLE 584
|
||||
#define K_SYSCALL_UART_IRQ_TX_ENABLE 585
|
||||
#define K_SYSCALL_UART_IRQ_UPDATE 586
|
||||
#define K_SYSCALL_UART_LINE_CTRL_GET 587
|
||||
#define K_SYSCALL_UART_LINE_CTRL_SET 588
|
||||
#define K_SYSCALL_UART_POLL_IN 589
|
||||
#define K_SYSCALL_UART_POLL_IN_U16 590
|
||||
#define K_SYSCALL_UART_POLL_OUT 591
|
||||
#define K_SYSCALL_UART_POLL_OUT_U16 592
|
||||
#define K_SYSCALL_UART_RX_DISABLE 593
|
||||
#define K_SYSCALL_UART_RX_ENABLE 594
|
||||
#define K_SYSCALL_UART_RX_ENABLE_U16 595
|
||||
#define K_SYSCALL_UART_TX 596
|
||||
#define K_SYSCALL_UART_TX_ABORT 597
|
||||
#define K_SYSCALL_UART_TX_U16 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_XTENSA_USER_FAULT 620
|
||||
#define K_SYSCALL_ZSOCK_ACCEPT 621
|
||||
#define K_SYSCALL_ZSOCK_BIND 622
|
||||
#define K_SYSCALL_ZSOCK_CLOSE 623
|
||||
#define K_SYSCALL_ZSOCK_CONNECT 624
|
||||
#define K_SYSCALL_ZSOCK_FCNTL_IMPL 625
|
||||
#define K_SYSCALL_ZSOCK_GETHOSTNAME 626
|
||||
#define K_SYSCALL_ZSOCK_GETPEERNAME 627
|
||||
#define K_SYSCALL_ZSOCK_GETSOCKNAME 628
|
||||
#define K_SYSCALL_ZSOCK_GETSOCKOPT 629
|
||||
#define K_SYSCALL_ZSOCK_GET_CONTEXT_OBJECT 630
|
||||
#define K_SYSCALL_ZSOCK_INET_PTON 631
|
||||
#define K_SYSCALL_ZSOCK_IOCTL_IMPL 632
|
||||
#define K_SYSCALL_ZSOCK_LISTEN 633
|
||||
#define K_SYSCALL_ZSOCK_RECVFROM 634
|
||||
#define K_SYSCALL_ZSOCK_RECVMSG 635
|
||||
#define K_SYSCALL_ZSOCK_SENDMSG 636
|
||||
#define K_SYSCALL_ZSOCK_SENDTO 637
|
||||
#define K_SYSCALL_ZSOCK_SETSOCKOPT 638
|
||||
#define K_SYSCALL_ZSOCK_SHUTDOWN 639
|
||||
#define K_SYSCALL_ZSOCK_SOCKET 640
|
||||
#define K_SYSCALL_ZSOCK_SOCKETPAIR 641
|
||||
#define K_SYSCALL_ZVFS_POLL 642
|
||||
#define K_SYSCALL_ZVFS_SELECT 643
|
||||
#define K_SYSCALL_Z_ERRNO 644
|
||||
#define K_SYSCALL_Z_ZSOCK_GETADDRINFO_INTERNAL 645
|
||||
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#endif /* _ASMLANGUAGE */
|
||||
|
||||
#endif /* ZEPHYR_SYSCALL_LIST_H */
|
||||
@@ -1,26 +0,0 @@
|
||||
#ifndef _APP_VERSION_H_
|
||||
#define _APP_VERSION_H_
|
||||
|
||||
/* The template values come from cmake/modules/version.cmake
|
||||
* BUILD_VERSION related template values will be 'git describe',
|
||||
* alternatively user defined BUILD_VERSION.
|
||||
*/
|
||||
|
||||
/* #undef ZEPHYR_VERSION_CODE */
|
||||
/* #undef ZEPHYR_VERSION */
|
||||
|
||||
#define APPVERSION 0x2040000
|
||||
#define APP_VERSION_NUMBER 0x20400
|
||||
#define APP_VERSION_MAJOR 2
|
||||
#define APP_VERSION_MINOR 4
|
||||
#define APP_PATCHLEVEL 0
|
||||
#define APP_TWEAK 0
|
||||
#define APP_EXTRAVERSION
|
||||
#define APP_VERSION_STRING "2.4.0"
|
||||
#define APP_VERSION_EXTENDED_STRING "2.4.0+0"
|
||||
#define APP_VERSION_TWEAK_STRING "2.4.0+0"
|
||||
|
||||
#define APP_BUILD_VERSION v2.4.0-41-ge36d3c8d6ca5
|
||||
|
||||
|
||||
#endif /* _APP_VERSION_H_ */
|
||||
@@ -1,432 +0,0 @@
|
||||
#define CONFIG_MCUBOOT 1
|
||||
#define CONFIG_BOOT_USE_TINYCRYPT 1
|
||||
#define CONFIG_BOOT_SOMETHING_USES_SHA256 1
|
||||
#define CONFIG_BOOT_IMG_HASH_ALG_SHA256_ALLOW 1
|
||||
#define CONFIG_BOOT_IMG_HASH_ALG_SHA256 1
|
||||
#define CONFIG_BOOT_SIGNATURE_TYPE_NONE 1
|
||||
#define CONFIG_MCUBOOT_CLEANUP_ARM_CORE 1
|
||||
#define CONFIG_MBEDTLS_CONFIG_FILE "mcuboot-mbedtls-cfg.h"
|
||||
#define CONFIG_BOOT_VALIDATE_SLOT0 1
|
||||
#define CONFIG_BOOT_PREFER_SWAP_OFFSET 1
|
||||
#define CONFIG_BOOT_SWAP_USING_MOVE 1
|
||||
#define CONFIG_BOOT_MAX_IMG_SECTORS_AUTO 1
|
||||
#define CONFIG_BOOT_SHARE_BACKEND_DISABLED 1
|
||||
#define CONFIG_BOOT_FIH_PROFILE_OFF 1
|
||||
#define CONFIG_MCUBOOT_LOG_LEVEL_INF 1
|
||||
#define CONFIG_MCUBOOT_LOG_LEVEL 3
|
||||
#define CONFIG_MCUBOOT_LOG_THREAD_STACK_SIZE 768
|
||||
#define CONFIG_BOOT_USB_DFU_NO 1
|
||||
#define CONFIG_UPDATEABLE_IMAGE_NUMBER 1
|
||||
#define CONFIG_MCUBOOT_BOOT_BANNER 1
|
||||
#define CONFIG_BOOT_BANNER_STRING "Using Zephyr OS build"
|
||||
#define CONFIG_MCUBOOT_USE_TLV_ALLOW_LIST 1
|
||||
#define CONFIG_MCUBOOT_STORAGE_WITH_ERASE 1
|
||||
#define CONFIG_MCUBOOT_DEVICE_SETTINGS 1
|
||||
#define CONFIG_MULTITHREADING 1
|
||||
#define CONFIG_USB_DEVICE_PRODUCT "MCUBOOT"
|
||||
#define CONFIG_MCUBOOT_BOOTUTIL_LIB_OWN_LOG 1
|
||||
#define CONFIG_DT_HAS_ARDUINO_HEADER_R3_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ARM_ARMV7M_SYSTICK_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ARM_CORTEX_M4F_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ARM_V7M_NVIC_ENABLED 1
|
||||
#define CONFIG_DT_HAS_FIXED_CLOCK_ENABLED 1
|
||||
#define CONFIG_DT_HAS_FIXED_LAYOUT_ENABLED 1
|
||||
#define CONFIG_DT_HAS_GPIO_KEYS_ENABLED 1
|
||||
#define CONFIG_DT_HAS_GPIO_LEDS_ENABLED 1
|
||||
#define CONFIG_DT_HAS_MMIO_SRAM_ENABLED 1
|
||||
#define CONFIG_DT_HAS_PWM_LEDS_ENABLED 1
|
||||
#define CONFIG_DT_HAS_SOC_NV_FLASH_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_DAC_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_EXTI_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_FLASH_CONTROLLER_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_GPIO_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_HSE_CLOCK_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_I2C_V2_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_LPTIM_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_LPUART_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_LSE_CLOCK_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_NV_FLASH_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_NVM_OTP_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_PINCTRL_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_PWM_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_RCC_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_RCC_RCTL_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_RNG_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_RTC_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_SPI_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_SPI_FIFO_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_TIMERS_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_UART_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_USART_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_WATCHDOG_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32G4_FLASH_CONTROLLER_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32G4_PLL_CLOCK_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_MORPHO_HEADER_ENABLED 1
|
||||
#define CONFIG_DT_HAS_USB_NOP_XCEIV_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ZEPHYR_MAPPED_PARTITION_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 10240
|
||||
#define CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE 1024
|
||||
#define CONFIG_NUM_IRQS 92
|
||||
#define CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC 170000000
|
||||
#define CONFIG_FLASH_SIZE 128
|
||||
#define CONFIG_FLASH_BASE_ADDRESS 0x8000000
|
||||
#define CONFIG_MP_MAX_NUM_CPUS 1
|
||||
#define CONFIG_DCACHE_LINE_SIZE 32
|
||||
#define CONFIG_ICACHE_LINE_SIZE 32
|
||||
#define CONFIG_IDLE_STACK_SIZE 320
|
||||
#define CONFIG_ISR_STACK_SIZE 2048
|
||||
#define CONFIG_CLOCK_CONTROL 1
|
||||
#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_XIP 1
|
||||
#define CONFIG_HAS_FLASH_LOAD_OFFSET 1
|
||||
#define CONFIG_CPU_HAS_ARM_MPU 1
|
||||
#define CONFIG_STM32_FLASH_PREFETCH 1
|
||||
#define CONFIG_TICKLESS_KERNEL 1
|
||||
#define CONFIG_CORTEX_M_SYSTICK 1
|
||||
#define CONFIG_CLOCK_CONTROL_INIT_PRIORITY 1
|
||||
#define CONFIG_USE_DT_CODE_PARTITION 1
|
||||
#define CONFIG_STM32_BACKUP_PROTECTION 1
|
||||
#define CONFIG_NUM_METAIRQ_PRIORITIES 0
|
||||
#define CONFIG_NUM_PREEMPT_PRIORITIES 15
|
||||
#define CONFIG_BUILD_OUTPUT_HEX 1
|
||||
#define CONFIG_GEN_IRQ_VECTOR_TABLE 1
|
||||
#define CONFIG_GEN_ISR_TABLES 1
|
||||
#define CONFIG_TIMESLICE_SIZE 20
|
||||
#define CONFIG_SYS_CLOCK_EXISTS 1
|
||||
#define CONFIG_FLASH_FILL_BUFFER_SIZE 32
|
||||
#define CONFIG_FLASH 1
|
||||
#define CONFIG_HW_STACK_PROTECTION 1
|
||||
#define CONFIG_LOG 1
|
||||
#define CONFIG_ARCH_SW_ISR_TABLE_ALIGN 4
|
||||
#define CONFIG_LOG_DOMAIN_NAME ""
|
||||
#define CONFIG_SOC_EARLY_INIT_HOOK 1
|
||||
#define CONFIG_COMMON_LIBC_MALLOC_ARENA_SIZE 0
|
||||
#define CONFIG_GEN_SW_ISR_TABLE 1
|
||||
#define CONFIG_FLASH_INIT_PRIORITY 50
|
||||
#define CONFIG_GEN_IRQ_START_VECTOR 0
|
||||
#define CONFIG_SRAM_OFFSET 0x0
|
||||
#define CONFIG_ARCH_IRQ_VECTOR_TABLE_ALIGN 4
|
||||
#define CONFIG_ISR_TABLES_LOCAL_DECLARATION_SUPPORTED 1
|
||||
#define CONFIG_KERNEL_MEM_POOL 1
|
||||
#define CONFIG_LINKER_USE_RELAX 1
|
||||
#define CONFIG_ZEPHYR_ACPICA_MODULE 1
|
||||
#define CONFIG_ZEPHYR_CMSIS_MODULE 1
|
||||
#define CONFIG_HAS_CMSIS_CORE 1
|
||||
#define CONFIG_ZEPHYR_CMSIS_DSP_MODULE 1
|
||||
#define CONFIG_ZEPHYR_CMSIS_NN_MODULE 1
|
||||
#define CONFIG_ZEPHYR_CMSIS_6_MODULE 1
|
||||
#define CONFIG_HAS_CMSIS_CORE_M 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_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_REALTEK_BEE_NVIC 1
|
||||
#define CONFIG_REALTEK_BEE_COMMON_DRIVER 1
|
||||
#define CONFIG_WRAP_REALTEK_BEE_NVIC 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_ZEPHYR_LVGL_MODULE 1
|
||||
#define CONFIG_ZEPHYR_MBEDTLS_MODULE 1
|
||||
#define CONFIG_MBEDTLS_PROMPTLESS 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_MLDSA_NATIVE_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_HAS_SEGGER_RTT 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_STM32CUBE 1
|
||||
#define CONFIG_USE_STM32_LL_UTILS 1
|
||||
#define CONFIG_MCUBOOT_BOOTUTIL_LIB 1
|
||||
#define CONFIG_MCUBOOT_UTIL_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_MCUBOOT_UTIL_LOG_LEVEL 0
|
||||
#define CONFIG_MCUBOOT_BOOT_MAX_ALIGN 8
|
||||
#define CONFIG_BOARD "nucleo_g431rb"
|
||||
#define CONFIG_BOARD_REVISION ""
|
||||
#define CONFIG_BOARD_TARGET "nucleo_g431rb/stm32g431xx"
|
||||
#define CONFIG_BOARD_NUCLEO_G431RB 1
|
||||
#define CONFIG_BOARD_NUCLEO_G431RB_STM32G431XX 1
|
||||
#define CONFIG_BOARD_QUALIFIERS "stm32g431xx"
|
||||
#define CONFIG_SOC "stm32g431xx"
|
||||
#define CONFIG_SOC_SERIES "stm32g4x"
|
||||
#define CONFIG_SOC_FAMILY "stm32"
|
||||
#define CONFIG_SOC_FAMILY_STM32 1
|
||||
#define CONFIG_SOC_SERIES_STM32G4X 1
|
||||
#define CONFIG_SOC_STM32G431XX 1
|
||||
#define CONFIG_SWJ_ANALOG_PRIORITY 49
|
||||
#define CONFIG_STM32_IOCELL_PRIORITY 50
|
||||
#define CONFIG_HAS_STM32_FLASH_PREFETCH 1
|
||||
#define CONFIG_SOC_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_SOC_LOG_LEVEL 0
|
||||
#define CONFIG_ARCH "arm"
|
||||
#define CONFIG_ARCH_HAS_SINGLE_THREAD_SUPPORT 1
|
||||
#define CONFIG_CPU_CORTEX 1
|
||||
#define CONFIG_ARM_MPU_REGION_MIN_ALIGN_AND_SIZE 32
|
||||
#define CONFIG_MPU_ALLOW_FLASH_WRITE 1
|
||||
#define CONFIG_CPU_CORTEX_M 1
|
||||
#define CONFIG_ISA_THUMB2 1
|
||||
#define CONFIG_ASSEMBLER_ISA_THUMB2 1
|
||||
#define CONFIG_COMPILER_ISA_THUMB2 1
|
||||
#define CONFIG_STACK_ALIGN_DOUBLE_WORD 1
|
||||
#define CONFIG_FAULT_DUMP 2
|
||||
#define CONFIG_ARM_STACK_PROTECTION 1
|
||||
#define CONFIG_FP16 1
|
||||
#define CONFIG_FP16_IEEE 1
|
||||
#define CONFIG_CPU_CORTEX_M4 1
|
||||
#define CONFIG_CPU_CORTEX_M_HAS_SYSTICK 1
|
||||
#define CONFIG_CPU_CORTEX_M_HAS_DWT 1
|
||||
#define CONFIG_CPU_CORTEX_M_HAS_BASEPRI 1
|
||||
#define CONFIG_CPU_CORTEX_M_HAS_VTOR 1
|
||||
#define CONFIG_CPU_CORTEX_M_HAS_PROGRAMMABLE_FAULT_PRIOS 1
|
||||
#define CONFIG_ARMV7_M_ARMV8_M_MAINLINE 1
|
||||
#define CONFIG_ARMV7_M_ARMV8_M_FP 1
|
||||
#define CONFIG_NULL_POINTER_EXCEPTION_DETECTION_NONE 1
|
||||
#define CONFIG_MPU_STACK_GUARD 1
|
||||
#define CONFIG_CUSTOM_SECTION_MIN_ALIGN_SIZE 32
|
||||
#define CONFIG_HAS_SWO 1
|
||||
#define CONFIG_ARCH_HAS_LLEXT_VENEERS 1
|
||||
#define CONFIG_ARM 1
|
||||
#define CONFIG_ARCH_IS_SET 1
|
||||
#define CONFIG_ARCH_SUPPORTS_ROM_OFFSET 1
|
||||
#define CONFIG_ARM_MPU 1
|
||||
#define CONFIG_ARCH_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_ARCH_LOG_LEVEL 0
|
||||
#define CONFIG_LITTLE_ENDIAN 1
|
||||
#define CONFIG_SRAM_SIZE 32
|
||||
#define CONFIG_SRAM_BASE_ADDRESS 0x20000000
|
||||
#define CONFIG_GEN_PRIV_STACKS 1
|
||||
#define CONFIG_ARCH_DEVICE_STATE_ALIGN 4
|
||||
#define CONFIG_IRQ_VECTOR_TABLE_JUMP_BY_ADDRESS 1
|
||||
#define CONFIG_GEN_SW_ISR_TABLE_ARRAY 1
|
||||
#define CONFIG_EXCEPTION_DEBUG 1
|
||||
#define CONFIG_ARCH_MEM_DOMAIN_SUPPORTS_ISOLATED_STACKS 1
|
||||
#define CONFIG_ARCH_HAS_TIMING_FUNCTIONS 1
|
||||
#define CONFIG_ARCH_HAS_STACK_PROTECTION 1
|
||||
#define CONFIG_ARCH_HAS_USERSPACE 1
|
||||
#define CONFIG_ARCH_HAS_EXECUTABLE_PAGE_BIT 1
|
||||
#define CONFIG_ARCH_HAS_RAMFUNC_SUPPORT 1
|
||||
#define CONFIG_ARCH_HAS_VECTOR_TABLE_RELOCATION 1
|
||||
#define CONFIG_ARCH_HAS_NESTED_EXCEPTION_DETECTION 1
|
||||
#define CONFIG_ARCH_SUPPORTS_COREDUMP 1
|
||||
#define CONFIG_ARCH_SUPPORTS_COREDUMP_THREADS 1
|
||||
#define CONFIG_ARCH_SUPPORTS_COREDUMP_STACK_PTR 1
|
||||
#define CONFIG_ARCH_SUPPORTS_ARCH_HW_INIT 1
|
||||
#define CONFIG_ARCH_SUPPORTS_ROM_START 1
|
||||
#define CONFIG_ARCH_HAS_EXTRA_EXCEPTION_INFO 1
|
||||
#define CONFIG_ARCH_HAS_THREAD_LOCAL_STORAGE 1
|
||||
#define CONFIG_ARCH_HAS_SUSPEND_TO_RAM 1
|
||||
#define CONFIG_ARCH_HAS_THREAD_ABORT 1
|
||||
#define CONFIG_ARCH_HAS_CODE_DATA_RELOCATION 1
|
||||
#define CONFIG_CPU_HAS_FPU 1
|
||||
#define CONFIG_CPU_HAS_MPU 1
|
||||
#define CONFIG_MPU 1
|
||||
#define CONFIG_MPU_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_MPU_LOG_LEVEL 0
|
||||
#define CONFIG_MPU_REQUIRES_POWER_OF_TWO_ALIGNMENT 1
|
||||
#define CONFIG_SRAM_REGION_PERMISSIONS 1
|
||||
#define CONFIG_TOOLCHAIN_HAS_BUILTIN_FFS 1
|
||||
#define CONFIG_ARCH_HAS_CUSTOM_SWAP_TO_MAIN 1
|
||||
#define CONFIG_KERNEL_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_KERNEL_LOG_LEVEL 0
|
||||
#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_CURRENT_THREAD_USE_TLS 1
|
||||
#define CONFIG_SYSTEM_WORKQUEUE_PRIORITY -1
|
||||
#define CONFIG_SYSTEM_WORKQUEUE_WORK_TIMEOUT_MS 0
|
||||
#define CONFIG_BARRIER_OPERATIONS_ARCH 1
|
||||
#define CONFIG_TIMESLICING 1
|
||||
#define CONFIG_TIMESLICE_PRIORITY 0
|
||||
#define CONFIG_NUM_MBOX_ASYNC_MSGS 10
|
||||
#define CONFIG_HEAP_MEM_POOL_SIZE 0
|
||||
#define CONFIG_SWAP_NONATOMIC 1
|
||||
#define CONFIG_TIMEOUT_64BIT 1
|
||||
#define CONFIG_SYS_CLOCK_MAX_TIMEOUT_DAYS 365
|
||||
#define CONFIG_USE_SWITCH_SUPPORTED 1
|
||||
#define CONFIG_TOOLCHAIN_SUPPORTS_THREAD_LOCAL_STORAGE 1
|
||||
#define CONFIG_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 0
|
||||
#define CONFIG_CLOCK_CONTROL_STM32_CUBE 1
|
||||
#define CONFIG_CLOCK_STM32_HSE_CLOCK 24000000
|
||||
#define CONFIG_CLOCK_CONTROL_TISCI_PRIORITY 40
|
||||
#define CONFIG_FLASH_HAS_DRIVER_ENABLED 1
|
||||
#define CONFIG_FLASH_HAS_EXPLICIT_ERASE 1
|
||||
#define CONFIG_FLASH_HAS_PAGE_LAYOUT 1
|
||||
#define CONFIG_FLASH_PAGE_LAYOUT 1
|
||||
#define CONFIG_SOC_FLASH_STM32 1
|
||||
#define CONFIG_FLASH_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_FLASH_LOG_LEVEL 0
|
||||
#define CONFIG_INTC_INIT_PRIORITY 40
|
||||
#define CONFIG_INTC_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_INTC_LOG_LEVEL 0
|
||||
#define CONFIG_EXTI_STM32 1
|
||||
#define CONFIG_GPIO_INTC_STM32 1
|
||||
#define CONFIG_TIMER_HAS_64BIT_CYCLE_COUNTER 1
|
||||
#define CONFIG_SYSTEM_CLOCK_INIT_PRIORITY 0
|
||||
#define CONFIG_TICKLESS_CAPABLE 1
|
||||
#define CONFIG_SYSTEM_TIMER_HAS_DISABLE_SUPPORT 1
|
||||
#define CONFIG_CORTEX_M_SYSTICK_INSTALL_ISR 1
|
||||
#define CONFIG_CORTEX_M_SYSTICK_64BIT_CYCLE_COUNTER 1
|
||||
#define CONFIG_SYSTEM_TIMER_HAS_LPM_COMPANION_SUPPORT 1
|
||||
#define CONFIG_SYSTEM_TIMER_LPM_COMPANION_NONE 1
|
||||
#define CONFIG_STM32_USB_COMMON_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_STM32_USB_COMMON_LOG_LEVEL 0
|
||||
#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_LIBC_ERRNO 1
|
||||
#define CONFIG_ERRNO 1
|
||||
#define CONFIG_PICOLIBC_USE_TOOLCHAIN 1
|
||||
#define CONFIG_PICOLIBC_IO_MINIMAL 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 0
|
||||
#define CONFIG_SYS_HEAP_SMALL_ONLY 1
|
||||
#define CONFIG_BOOT_BANNER 1
|
||||
#define CONFIG_BOOT_DELAY 0
|
||||
#define CONFIG_ATOMIC_OPERATIONS_BUILTIN 1
|
||||
#define CONFIG_CBPRINTF_NANO 1
|
||||
#define CONFIG_CBPRINTF_FULL_INTEGRAL 1
|
||||
#define CONFIG_CBPRINTF_PACKAGE_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_CBPRINTF_PACKAGE_LOG_LEVEL 0
|
||||
#define CONFIG_CBPRINTF_CONVERT_CHECK_PTR 1
|
||||
#define CONFIG_CPU_LOAD_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_CPU_LOAD_LOG_LEVEL 0
|
||||
#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_OPENAMP_VRING_ALIGNMENT 16
|
||||
#define CONFIG_LOG_CORE_INIT_PRIORITY 0
|
||||
#define CONFIG_LOG_MODE_MINIMAL 1
|
||||
#define CONFIG_LOG_DEFAULT_LEVEL 0
|
||||
#define CONFIG_LOG_OVERRIDE_LEVEL 0
|
||||
#define CONFIG_LOG_MAX_LEVEL 4
|
||||
#define CONFIG_LOG_USE_VLA 1
|
||||
#define CONFIG_LOG_SIMPLE_MSG_OPTIMIZE 1
|
||||
#define CONFIG_LOG_RATELIMIT 1
|
||||
#define CONFIG_LOG_RATELIMIT_INTERVAL_MS 5000
|
||||
#define CONFIG_MEM_ATTR 1
|
||||
#define CONFIG_HAS_PM 1
|
||||
#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_TIMER_RANDOM_INITIAL_STATE 123456789
|
||||
#define CONFIG_ENTROPY_NODE_ENABLED 1
|
||||
#define CONFIG_FLASH_MAP 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_USES_MAPPED_PARTITION 1
|
||||
#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_LAST_SECTION_ID 1
|
||||
#define CONFIG_LINKER_LAST_SECTION_ID_PATTERN 0xE015E015
|
||||
#define CONFIG_LINKER_ITERABLE_SUBALIGN 4
|
||||
#define CONFIG_LINKER_DEVNULL_SUPPORT 1
|
||||
#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_IS_BOOTLOADER 1
|
||||
#define CONFIG_LEGACY_GENERATED_INCLUDE_PATH 1
|
||||
+18
-18
@@ -18524,7 +18524,7 @@
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_REG_NUM 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_REG_IDX_0_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_REG_IDX_0_VAL_ADDRESS 134217728 /* 0x8000000 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_REG_IDX_0_VAL_SIZE 34816 /* 0x8800 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_REG_IDX_0_VAL_SIZE 32768 /* 0x8000 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_FOREACH_REG(fn) fn(DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0, 0)
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_FOREACH_REG_SEP(fn, sep) fn(DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0, 0)
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_FOREACH_REG_VARGS(fn, ...) fn(DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0, 0, __VA_ARGS__)
|
||||
@@ -18561,11 +18561,11 @@
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_P_label_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_P_read_only 0
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_P_read_only_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_P_reg {0 /* 0x0 */, 34816 /* 0x8800 */}
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_P_reg {0 /* 0x0 */, 32768 /* 0x8000 */}
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_P_reg_IDX_0_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_P_reg_IDX_0 0
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_P_reg_IDX_1_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_P_reg_IDX_1 34816
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_P_reg_IDX_1 32768
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_P_reg_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_P_compatible {"zephyr,mapped-partition"}
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_0_P_compatible_IDX_0_EXISTS 1
|
||||
@@ -18655,8 +18655,8 @@
|
||||
/* Macros for properties that are special in the specification: */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_REG_NUM 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_REG_IDX_0_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_REG_IDX_0_VAL_ADDRESS 134252544 /* 0x8008800 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_REG_IDX_0_VAL_SIZE 49152 /* 0xc000 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_REG_IDX_0_VAL_ADDRESS 134250496 /* 0x8008000 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_REG_IDX_0_VAL_SIZE 65536 /* 0x10000 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_FOREACH_REG(fn) fn(DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800, 0)
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_FOREACH_REG_SEP(fn, sep) fn(DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800, 0)
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_FOREACH_REG_VARGS(fn, ...) fn(DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800, 0, __VA_ARGS__)
|
||||
@@ -18693,11 +18693,11 @@
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_P_label_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_P_read_only 0
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_P_read_only_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_P_reg {34816 /* 0x8800 */, 49152 /* 0xc000 */}
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_P_reg {32768 /* 0x8000 */, 65536 /* 0x10000 */}
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_P_reg_IDX_0_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_P_reg_IDX_0 34816
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_P_reg_IDX_0 32768
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_P_reg_IDX_1_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_P_reg_IDX_1 49152
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_P_reg_IDX_1 65536
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_P_reg_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_P_compatible {"zephyr,mapped-partition"}
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_8800_P_compatible_IDX_0_EXISTS 1
|
||||
@@ -18787,8 +18787,8 @@
|
||||
/* Macros for properties that are special in the specification: */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_REG_NUM 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_REG_IDX_0_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_REG_IDX_0_VAL_ADDRESS 134301696 /* 0x8014800 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_REG_IDX_0_VAL_SIZE 43008 /* 0xa800 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_REG_IDX_0_VAL_ADDRESS 134283264 /* 0x8010000 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_REG_IDX_0_VAL_SIZE 98304 /* 0x18000 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_FOREACH_REG(fn) fn(DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800, 0)
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_FOREACH_REG_SEP(fn, sep) fn(DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800, 0)
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_FOREACH_REG_VARGS(fn, ...) fn(DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800, 0, __VA_ARGS__)
|
||||
@@ -18825,11 +18825,11 @@
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_P_label_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_P_read_only 0
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_P_read_only_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_P_reg {83968 /* 0x14800 */, 43008 /* 0xa800 */}
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_P_reg {65536 /* 0x10000 */, 98304 /* 0x18000 */}
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_P_reg_IDX_0_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_P_reg_IDX_0 83968
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_P_reg_IDX_0 65536
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_P_reg_IDX_1_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_P_reg_IDX_1 43008
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_P_reg_IDX_1 98304
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_P_reg_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_P_compatible {"zephyr,mapped-partition"}
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_14800_P_compatible_IDX_0_EXISTS 1
|
||||
@@ -18919,8 +18919,8 @@
|
||||
/* Macros for properties that are special in the specification: */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_REG_NUM 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_REG_IDX_0_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_REG_IDX_0_VAL_ADDRESS 134344704 /* 0x801f000 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_REG_IDX_0_VAL_SIZE 4096 /* 0x1000 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_REG_IDX_0_VAL_ADDRESS 134316032 /* 0x8018000 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_REG_IDX_0_VAL_SIZE 131072 /* 0x20000 */
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_FOREACH_REG(fn) fn(DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000, 0)
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_FOREACH_REG_SEP(fn, sep) fn(DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000, 0)
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_FOREACH_REG_VARGS(fn, ...) fn(DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000, 0, __VA_ARGS__)
|
||||
@@ -18957,11 +18957,11 @@
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_P_label_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_P_read_only 0
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_P_read_only_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_P_reg {126976 /* 0x1f000 */, 4096 /* 0x1000 */}
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_P_reg {98304 /* 0x18000 */, 131072 /* 0x20000 */}
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_P_reg_IDX_0_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_P_reg_IDX_0 126976
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_P_reg_IDX_0 98304
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_P_reg_IDX_1_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_P_reg_IDX_1 4096
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_P_reg_IDX_1 131072
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_P_reg_EXISTS 1
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_P_compatible {"zephyr,mapped-partition"}
|
||||
#define DT_N_S_soc_S_flash_controller_40022000_S_flash_8000000_S_partitions_S_partition_1f000_P_compatible_IDX_0_EXISTS 1
|
||||
|
||||
@@ -1,192 +0,0 @@
|
||||
#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_FLASH(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, flash, FLASH)
|
||||
|
||||
#define K_SYSCALL_DRIVER_SHARED_IRQ(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, shared_irq, SHARED_IRQ)
|
||||
|
||||
#define K_SYSCALL_DRIVER_DMIC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, dmic, DMIC)
|
||||
|
||||
#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_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_GPIO(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, gpio, GPIO)
|
||||
|
||||
#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_SPI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, spi, SPI)
|
||||
|
||||
#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_TGPIO(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, tgpio, TGPIO)
|
||||
|
||||
#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_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 */
|
||||
@@ -1,19 +0,0 @@
|
||||
/* 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__ */
|
||||
@@ -1,141 +0,0 @@
|
||||
/* 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_FLASH,
|
||||
K_OBJ_DRIVER_SHARED_IRQ,
|
||||
K_OBJ_DRIVER_DMIC,
|
||||
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_FPGA,
|
||||
K_OBJ_DRIVER_FUEL_GAUGE,
|
||||
K_OBJ_DRIVER_GNSS,
|
||||
K_OBJ_DRIVER_GPIO,
|
||||
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_SPI,
|
||||
K_OBJ_DRIVER_SYSCON,
|
||||
K_OBJ_DRIVER_TEE,
|
||||
K_OBJ_DRIVER_TGPIO,
|
||||
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_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,
|
||||
@@ -1,35 +0,0 @@
|
||||
/* 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 0x74
|
||||
#define ___thread_t_stack_info_OFFSET 0x60
|
||||
#define ___thread_t_tls_OFFSET 0x70
|
||||
#define __z_interrupt_stack_SIZEOF 0x840
|
||||
#define __z_interrupt_all_stacks_SIZEOF 0x840
|
||||
#define _PM_DEVICE_STRUCT_FLAGS_OFFSET 0x0
|
||||
#define ___thread_arch_t_basepri_OFFSET 0x0
|
||||
#define ___thread_arch_t_swap_return_value_OFFSET 0x4
|
||||
#define ___basic_sf_t_pc_OFFSET 0x18
|
||||
#define ___basic_sf_t_xpsr_OFFSET 0x1c
|
||||
#define ___esf_t_SIZEOF 0x20
|
||||
#define ___callee_saved_t_SIZEOF 0x24
|
||||
#define ___thread_stack_info_t_start_OFFSET 0x0
|
||||
|
||||
#endif /* __GEN_OFFSETS_H__ */
|
||||
@@ -1,15 +0,0 @@
|
||||
/* 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
|
||||
@@ -1,141 +0,0 @@
|
||||
/* 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_FLASH: ret = "flash driver"; break;
|
||||
case K_OBJ_DRIVER_SHARED_IRQ: ret = "shared_irq driver"; break;
|
||||
case K_OBJ_DRIVER_DMIC: ret = "dmic 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_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_GPIO: ret = "gpio 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_SPI: ret = "spi driver"; break;
|
||||
case K_OBJ_DRIVER_SYSCON: ret = "syscon driver"; break;
|
||||
case K_OBJ_DRIVER_TEE: ret = "tee driver"; break;
|
||||
case K_OBJ_DRIVER_TGPIO: ret = "tgpio 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_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;
|
||||
@@ -1,697 +0,0 @@
|
||||
/* 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_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_flash_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_flash_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_flash_erase(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_flash_get_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_flash_fill(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_flash_flatten(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_flash_get_page_info_by_offs(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_flash_get_page_info_by_idx(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_flash_get_page_count(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_flash_sfdp_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_flash_read_jedec_id(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_flash_get_write_block_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_flash_get_parameters(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_flash_ex_op(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_flash_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_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);
|
||||
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_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_FLASH_READ] = z_mrsh_flash_read,
|
||||
[K_SYSCALL_FLASH_WRITE] = z_mrsh_flash_write,
|
||||
[K_SYSCALL_FLASH_ERASE] = z_mrsh_flash_erase,
|
||||
[K_SYSCALL_FLASH_GET_SIZE] = z_mrsh_flash_get_size,
|
||||
[K_SYSCALL_FLASH_FILL] = z_mrsh_flash_fill,
|
||||
[K_SYSCALL_FLASH_FLATTEN] = z_mrsh_flash_flatten,
|
||||
[K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS] = z_mrsh_flash_get_page_info_by_offs,
|
||||
[K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX] = z_mrsh_flash_get_page_info_by_idx,
|
||||
[K_SYSCALL_FLASH_GET_PAGE_COUNT] = z_mrsh_flash_get_page_count,
|
||||
[K_SYSCALL_FLASH_SFDP_READ] = z_mrsh_flash_sfdp_read,
|
||||
[K_SYSCALL_FLASH_READ_JEDEC_ID] = z_mrsh_flash_read_jedec_id,
|
||||
[K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE] = z_mrsh_flash_get_write_block_size,
|
||||
[K_SYSCALL_FLASH_GET_PARAMETERS] = z_mrsh_flash_get_parameters,
|
||||
[K_SYSCALL_FLASH_EX_OP] = z_mrsh_flash_ex_op,
|
||||
[K_SYSCALL_FLASH_COPY] = z_mrsh_flash_copy,
|
||||
[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_BAD] = handler_bad_syscall
|
||||
};
|
||||
@@ -1,289 +0,0 @@
|
||||
/* 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_flash_copy;
|
||||
extern void * const z_impl_flash_erase;
|
||||
extern void * const z_impl_flash_ex_op;
|
||||
extern void * const z_impl_flash_fill;
|
||||
extern void * const z_impl_flash_flatten;
|
||||
extern void * const z_impl_flash_get_page_count;
|
||||
extern void * const z_impl_flash_get_page_info_by_idx;
|
||||
extern void * const z_impl_flash_get_page_info_by_offs;
|
||||
extern void * const z_impl_flash_get_parameters;
|
||||
extern void * const z_impl_flash_get_size;
|
||||
extern void * const z_impl_flash_get_write_block_size;
|
||||
extern void * const z_impl_flash_read;
|
||||
extern void * const z_impl_flash_read_jedec_id;
|
||||
extern void * const z_impl_flash_sfdp_read;
|
||||
extern void * const z_impl_flash_write;
|
||||
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_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_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_flash_copy);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_flash_erase);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_flash_ex_op);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_flash_fill);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_flash_flatten);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_flash_get_page_count);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_flash_get_page_info_by_idx);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_flash_get_page_info_by_offs);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_flash_get_parameters);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_flash_get_size);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_flash_get_write_block_size);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_flash_read);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_flash_read_jedec_id);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_flash_sfdp_read);
|
||||
EXPORT_GROUP_SYMBOL(SYSCALL, z_impl_flash_write);
|
||||
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_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_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);
|
||||
@@ -1,664 +0,0 @@
|
||||
/* 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_FLASH_COPY 5
|
||||
#define K_SYSCALL_FLASH_ERASE 6
|
||||
#define K_SYSCALL_FLASH_EX_OP 7
|
||||
#define K_SYSCALL_FLASH_FILL 8
|
||||
#define K_SYSCALL_FLASH_FLATTEN 9
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_COUNT 10
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX 11
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS 12
|
||||
#define K_SYSCALL_FLASH_GET_PARAMETERS 13
|
||||
#define K_SYSCALL_FLASH_GET_SIZE 14
|
||||
#define K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE 15
|
||||
#define K_SYSCALL_FLASH_READ 16
|
||||
#define K_SYSCALL_FLASH_READ_JEDEC_ID 17
|
||||
#define K_SYSCALL_FLASH_SFDP_READ 18
|
||||
#define K_SYSCALL_FLASH_WRITE 19
|
||||
#define K_SYSCALL_K_BUSY_WAIT 20
|
||||
#define K_SYSCALL_K_CONDVAR_BROADCAST 21
|
||||
#define K_SYSCALL_K_CONDVAR_INIT 22
|
||||
#define K_SYSCALL_K_CONDVAR_SIGNAL 23
|
||||
#define K_SYSCALL_K_CONDVAR_WAIT 24
|
||||
#define K_SYSCALL_K_EVENT_CLEAR 25
|
||||
#define K_SYSCALL_K_EVENT_INIT 26
|
||||
#define K_SYSCALL_K_EVENT_POST 27
|
||||
#define K_SYSCALL_K_EVENT_SET 28
|
||||
#define K_SYSCALL_K_EVENT_SET_MASKED 29
|
||||
#define K_SYSCALL_K_EVENT_WAIT 30
|
||||
#define K_SYSCALL_K_EVENT_WAIT_ALL 31
|
||||
#define K_SYSCALL_K_EVENT_WAIT_ALL_SAFE 32
|
||||
#define K_SYSCALL_K_EVENT_WAIT_SAFE 33
|
||||
#define K_SYSCALL_K_FLOAT_DISABLE 34
|
||||
#define K_SYSCALL_K_FLOAT_ENABLE 35
|
||||
#define K_SYSCALL_K_FUTEX_WAIT 36
|
||||
#define K_SYSCALL_K_FUTEX_WAKE 37
|
||||
#define K_SYSCALL_K_IS_PREEMPT_THREAD 38
|
||||
#define K_SYSCALL_K_MSGQ_ALLOC_INIT 39
|
||||
#define K_SYSCALL_K_MSGQ_GET 40
|
||||
#define K_SYSCALL_K_MSGQ_GET_ATTRS 41
|
||||
#define K_SYSCALL_K_MSGQ_NUM_FREE_GET 42
|
||||
#define K_SYSCALL_K_MSGQ_NUM_USED_GET 43
|
||||
#define K_SYSCALL_K_MSGQ_PEEK 44
|
||||
#define K_SYSCALL_K_MSGQ_PEEK_AT 45
|
||||
#define K_SYSCALL_K_MSGQ_PURGE 46
|
||||
#define K_SYSCALL_K_MSGQ_PUT 47
|
||||
#define K_SYSCALL_K_MSGQ_PUT_FRONT 48
|
||||
#define K_SYSCALL_K_MUTEX_INIT 49
|
||||
#define K_SYSCALL_K_MUTEX_LOCK 50
|
||||
#define K_SYSCALL_K_MUTEX_UNLOCK 51
|
||||
#define K_SYSCALL_K_OBJECT_ACCESS_CHECK 52
|
||||
#define K_SYSCALL_K_OBJECT_ACCESS_GRANT 53
|
||||
#define K_SYSCALL_K_OBJECT_ALLOC 54
|
||||
#define K_SYSCALL_K_OBJECT_ALLOC_SIZE 55
|
||||
#define K_SYSCALL_K_OBJECT_RELEASE 56
|
||||
#define K_SYSCALL_K_PIPE_CLOSE 57
|
||||
#define K_SYSCALL_K_PIPE_INIT 58
|
||||
#define K_SYSCALL_K_PIPE_READ 59
|
||||
#define K_SYSCALL_K_PIPE_RESET 60
|
||||
#define K_SYSCALL_K_PIPE_WRITE 61
|
||||
#define K_SYSCALL_K_POLL 62
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_CHECK 63
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_INIT 64
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_RAISE 65
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_RESET 66
|
||||
#define K_SYSCALL_K_QUEUE_ALLOC_APPEND 67
|
||||
#define K_SYSCALL_K_QUEUE_ALLOC_PREPEND 68
|
||||
#define K_SYSCALL_K_QUEUE_CANCEL_WAIT 69
|
||||
#define K_SYSCALL_K_QUEUE_GET 70
|
||||
#define K_SYSCALL_K_QUEUE_INIT 71
|
||||
#define K_SYSCALL_K_QUEUE_IS_EMPTY 72
|
||||
#define K_SYSCALL_K_QUEUE_PEEK_HEAD 73
|
||||
#define K_SYSCALL_K_QUEUE_PEEK_TAIL 74
|
||||
#define K_SYSCALL_K_RESCHEDULE 75
|
||||
#define K_SYSCALL_K_SCHED_CURRENT_THREAD_QUERY 76
|
||||
#define K_SYSCALL_K_SEM_COUNT_GET 77
|
||||
#define K_SYSCALL_K_SEM_GIVE 78
|
||||
#define K_SYSCALL_K_SEM_INIT 79
|
||||
#define K_SYSCALL_K_SEM_RESET 80
|
||||
#define K_SYSCALL_K_SEM_TAKE 81
|
||||
#define K_SYSCALL_K_SLEEP 82
|
||||
#define K_SYSCALL_K_STACK_ALLOC_INIT 83
|
||||
#define K_SYSCALL_K_STACK_POP 84
|
||||
#define K_SYSCALL_K_STACK_PUSH 85
|
||||
#define K_SYSCALL_K_STR_OUT 86
|
||||
#define K_SYSCALL_K_THREAD_ABORT 87
|
||||
#define K_SYSCALL_K_THREAD_ABSOLUTE_DEADLINE_SET 88
|
||||
#define K_SYSCALL_K_THREAD_CREATE 89
|
||||
#define K_SYSCALL_K_THREAD_CUSTOM_DATA_GET 90
|
||||
#define K_SYSCALL_K_THREAD_CUSTOM_DATA_SET 91
|
||||
#define K_SYSCALL_K_THREAD_DEADLINE_SET 92
|
||||
#define K_SYSCALL_K_THREAD_JOIN 93
|
||||
#define K_SYSCALL_K_THREAD_NAME_COPY 94
|
||||
#define K_SYSCALL_K_THREAD_NAME_SET 95
|
||||
#define K_SYSCALL_K_THREAD_PRIORITY_GET 96
|
||||
#define K_SYSCALL_K_THREAD_PRIORITY_SET 97
|
||||
#define K_SYSCALL_K_THREAD_RESUME 98
|
||||
#define K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_GET 99
|
||||
#define K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_PCT_SET 100
|
||||
#define K_SYSCALL_K_THREAD_RUNTIME_STACK_UNUSED_THRESHOLD_SET 101
|
||||
#define K_SYSCALL_K_THREAD_STACK_ALLOC 102
|
||||
#define K_SYSCALL_K_THREAD_STACK_FREE 103
|
||||
#define K_SYSCALL_K_THREAD_STACK_SPACE_GET 104
|
||||
#define K_SYSCALL_K_THREAD_SUSPEND 105
|
||||
#define K_SYSCALL_K_THREAD_TIMEOUT_EXPIRES_TICKS 106
|
||||
#define K_SYSCALL_K_THREAD_TIMEOUT_REMAINING_TICKS 107
|
||||
#define K_SYSCALL_K_TIMER_EXPIRES_TICKS 108
|
||||
#define K_SYSCALL_K_TIMER_REMAINING_TICKS 109
|
||||
#define K_SYSCALL_K_TIMER_START 110
|
||||
#define K_SYSCALL_K_TIMER_STATUS_GET 111
|
||||
#define K_SYSCALL_K_TIMER_STATUS_SYNC 112
|
||||
#define K_SYSCALL_K_TIMER_STOP 113
|
||||
#define K_SYSCALL_K_TIMER_USER_DATA_GET 114
|
||||
#define K_SYSCALL_K_TIMER_USER_DATA_SET 115
|
||||
#define K_SYSCALL_K_UPTIME_TICKS 116
|
||||
#define K_SYSCALL_K_USLEEP 117
|
||||
#define K_SYSCALL_K_WAKEUP 118
|
||||
#define K_SYSCALL_K_YIELD 119
|
||||
#define K_SYSCALL_LOG_BUFFERED_CNT 120
|
||||
#define K_SYSCALL_LOG_FILTER_SET 121
|
||||
#define K_SYSCALL_LOG_FRONTEND_FILTER_SET 122
|
||||
#define K_SYSCALL_LOG_PANIC 123
|
||||
#define K_SYSCALL_LOG_PROCESS 124
|
||||
#define K_SYSCALL_SYS_CLOCK_GETRTOFFSET 125
|
||||
#define K_SYSCALL_SYS_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_GET 126
|
||||
#define K_SYSCALL_SYS_CLOCK_NANOSLEEP 127
|
||||
#define K_SYSCALL_SYS_CLOCK_SETTIME 128
|
||||
#define K_SYSCALL_ZEPHYR_FPUTC 129
|
||||
#define K_SYSCALL_ZEPHYR_FWRITE 130
|
||||
#define K_SYSCALL_ZEPHYR_READ_STDIN 131
|
||||
#define K_SYSCALL_ZEPHYR_WRITE_STDOUT 132
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0 133
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1 134
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2 135
|
||||
#define K_SYSCALL_Z_LOG_MSG_STATIC_CREATE 136
|
||||
#define K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK 137
|
||||
#define K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK 138
|
||||
#define K_SYSCALL_BAD 139
|
||||
#define K_SYSCALL_LIMIT 140
|
||||
|
||||
|
||||
/* Following syscalls are not used in image */
|
||||
#define K_SYSCALL_ADC_CHANNEL_SETUP 141
|
||||
#define K_SYSCALL_ADC_GET_DECODER 142
|
||||
#define K_SYSCALL_ADC_READ 143
|
||||
#define K_SYSCALL_ADC_READ_ASYNC 144
|
||||
#define K_SYSCALL_ATOMIC_ADD 145
|
||||
#define K_SYSCALL_ATOMIC_AND 146
|
||||
#define K_SYSCALL_ATOMIC_CAS 147
|
||||
#define K_SYSCALL_ATOMIC_NAND 148
|
||||
#define K_SYSCALL_ATOMIC_OR 149
|
||||
#define K_SYSCALL_ATOMIC_PTR_CAS 150
|
||||
#define K_SYSCALL_ATOMIC_PTR_SET 151
|
||||
#define K_SYSCALL_ATOMIC_SET 152
|
||||
#define K_SYSCALL_ATOMIC_SUB 153
|
||||
#define K_SYSCALL_ATOMIC_XOR 154
|
||||
#define K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET 155
|
||||
#define K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET 156
|
||||
#define K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET 157
|
||||
#define K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET 158
|
||||
#define K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET 159
|
||||
#define K_SYSCALL_AUXDISPLAY_CLEAR 160
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET 161
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET 162
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED 163
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET 164
|
||||
#define K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET 165
|
||||
#define K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND 166
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_OFF 167
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_ON 168
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET 169
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET 170
|
||||
#define K_SYSCALL_AUXDISPLAY_IS_BUSY 171
|
||||
#define K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED 172
|
||||
#define K_SYSCALL_AUXDISPLAY_WRITE 173
|
||||
#define K_SYSCALL_BBRAM_CHECK_INVALID 174
|
||||
#define K_SYSCALL_BBRAM_CHECK_POWER 175
|
||||
#define K_SYSCALL_BBRAM_CHECK_STANDBY_POWER 176
|
||||
#define K_SYSCALL_BBRAM_GET_SIZE 177
|
||||
#define K_SYSCALL_BBRAM_READ 178
|
||||
#define K_SYSCALL_BBRAM_WRITE 179
|
||||
#define K_SYSCALL_BC12_SET_RESULT_CB 180
|
||||
#define K_SYSCALL_BC12_SET_ROLE 181
|
||||
#define K_SYSCALL_BIOMETRIC_ATTR_GET 182
|
||||
#define K_SYSCALL_BIOMETRIC_ATTR_SET 183
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_ABORT 184
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_CAPTURE 185
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_FINALIZE 186
|
||||
#define K_SYSCALL_BIOMETRIC_ENROLL_START 187
|
||||
#define K_SYSCALL_BIOMETRIC_GET_CAPABILITIES 188
|
||||
#define K_SYSCALL_BIOMETRIC_LED_CONTROL 189
|
||||
#define K_SYSCALL_BIOMETRIC_MATCH 190
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_DELETE 191
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_DELETE_ALL 192
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_LIST 193
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_READ 194
|
||||
#define K_SYSCALL_BIOMETRIC_TEMPLATE_STORE 195
|
||||
#define K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ 196
|
||||
#define K_SYSCALL_CAN_CALC_TIMING 197
|
||||
#define K_SYSCALL_CAN_CALC_TIMING_DATA 198
|
||||
#define K_SYSCALL_CAN_GET_BITRATE_MAX 199
|
||||
#define K_SYSCALL_CAN_GET_BITRATE_MIN 200
|
||||
#define K_SYSCALL_CAN_GET_CAPABILITIES 201
|
||||
#define K_SYSCALL_CAN_GET_CORE_CLOCK 202
|
||||
#define K_SYSCALL_CAN_GET_MAX_FILTERS 203
|
||||
#define K_SYSCALL_CAN_GET_MODE 204
|
||||
#define K_SYSCALL_CAN_GET_STATE 205
|
||||
#define K_SYSCALL_CAN_GET_TIMING_DATA_MAX 206
|
||||
#define K_SYSCALL_CAN_GET_TIMING_DATA_MIN 207
|
||||
#define K_SYSCALL_CAN_GET_TIMING_MAX 208
|
||||
#define K_SYSCALL_CAN_GET_TIMING_MIN 209
|
||||
#define K_SYSCALL_CAN_GET_TRANSCEIVER 210
|
||||
#define K_SYSCALL_CAN_RECOVER 211
|
||||
#define K_SYSCALL_CAN_REMOVE_RX_FILTER 212
|
||||
#define K_SYSCALL_CAN_SEND 213
|
||||
#define K_SYSCALL_CAN_SET_BITRATE 214
|
||||
#define K_SYSCALL_CAN_SET_BITRATE_DATA 215
|
||||
#define K_SYSCALL_CAN_SET_MODE 216
|
||||
#define K_SYSCALL_CAN_SET_TIMING 217
|
||||
#define K_SYSCALL_CAN_SET_TIMING_DATA 218
|
||||
#define K_SYSCALL_CAN_START 219
|
||||
#define K_SYSCALL_CAN_STATS_GET_ACK_ERRORS 220
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS 221
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS 222
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT_ERRORS 223
|
||||
#define K_SYSCALL_CAN_STATS_GET_CRC_ERRORS 224
|
||||
#define K_SYSCALL_CAN_STATS_GET_FORM_ERRORS 225
|
||||
#define K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS 226
|
||||
#define K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS 227
|
||||
#define K_SYSCALL_CAN_STOP 228
|
||||
#define K_SYSCALL_CHARGER_CHARGE_ENABLE 229
|
||||
#define K_SYSCALL_CHARGER_GET_PROP 230
|
||||
#define K_SYSCALL_CHARGER_SET_PROP 231
|
||||
#define K_SYSCALL_COMPARATOR_GET_OUTPUT 232
|
||||
#define K_SYSCALL_COMPARATOR_SET_TRIGGER 233
|
||||
#define K_SYSCALL_COMPARATOR_TRIGGER_IS_PENDING 234
|
||||
#define K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM 235
|
||||
#define K_SYSCALL_COUNTER_DISABLE_CAPTURE 236
|
||||
#define K_SYSCALL_COUNTER_ENABLE_CAPTURE 237
|
||||
#define K_SYSCALL_COUNTER_GET_FREQUENCY 238
|
||||
#define K_SYSCALL_COUNTER_GET_FREQUENCY_64 239
|
||||
#define K_SYSCALL_COUNTER_GET_GUARD_PERIOD 240
|
||||
#define K_SYSCALL_COUNTER_GET_GUARD_PERIOD_64 241
|
||||
#define K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE 242
|
||||
#define K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE_64 243
|
||||
#define K_SYSCALL_COUNTER_GET_NUM_OF_CHANNELS 244
|
||||
#define K_SYSCALL_COUNTER_GET_PENDING_INT 245
|
||||
#define K_SYSCALL_COUNTER_GET_TOP_VALUE 246
|
||||
#define K_SYSCALL_COUNTER_GET_TOP_VALUE_64 247
|
||||
#define K_SYSCALL_COUNTER_GET_VALUE 248
|
||||
#define K_SYSCALL_COUNTER_GET_VALUE_64 249
|
||||
#define K_SYSCALL_COUNTER_IS_COUNTING_UP 250
|
||||
#define K_SYSCALL_COUNTER_NS_TO_TICKS 251
|
||||
#define K_SYSCALL_COUNTER_NS_TO_TICKS_64 252
|
||||
#define K_SYSCALL_COUNTER_RESET 253
|
||||
#define K_SYSCALL_COUNTER_SET_CHANNEL_ALARM 254
|
||||
#define K_SYSCALL_COUNTER_SET_CHANNEL_ALARM_64 255
|
||||
#define K_SYSCALL_COUNTER_SET_GUARD_PERIOD 256
|
||||
#define K_SYSCALL_COUNTER_SET_GUARD_PERIOD_64 257
|
||||
#define K_SYSCALL_COUNTER_SET_TOP_VALUE 258
|
||||
#define K_SYSCALL_COUNTER_SET_TOP_VALUE_64 259
|
||||
#define K_SYSCALL_COUNTER_SET_VALUE 260
|
||||
#define K_SYSCALL_COUNTER_SET_VALUE_64 261
|
||||
#define K_SYSCALL_COUNTER_START 262
|
||||
#define K_SYSCALL_COUNTER_STOP 263
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_NS 264
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_NS_64 265
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_US 266
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_US_64 267
|
||||
#define K_SYSCALL_COUNTER_US_TO_TICKS 268
|
||||
#define K_SYSCALL_COUNTER_US_TO_TICKS_64 269
|
||||
#define K_SYSCALL_CRC_BEGIN 270
|
||||
#define K_SYSCALL_CRC_FINISH 271
|
||||
#define K_SYSCALL_CRC_UPDATE 272
|
||||
#define K_SYSCALL_DAC_CHANNEL_SETUP 273
|
||||
#define K_SYSCALL_DAC_WRITE_VALUE 274
|
||||
#define K_SYSCALL_DAI_CONFIG_GET 275
|
||||
#define K_SYSCALL_DAI_CONFIG_SET 276
|
||||
#define K_SYSCALL_DAI_CONFIG_UPDATE 277
|
||||
#define K_SYSCALL_DAI_GET_PROPERTIES_COPY 278
|
||||
#define K_SYSCALL_DAI_PROBE 279
|
||||
#define K_SYSCALL_DAI_REMOVE 280
|
||||
#define K_SYSCALL_DAI_TRIGGER 281
|
||||
#define K_SYSCALL_DAI_TS_CONFIG 282
|
||||
#define K_SYSCALL_DAI_TS_GET 283
|
||||
#define K_SYSCALL_DAI_TS_START 284
|
||||
#define K_SYSCALL_DAI_TS_STOP 285
|
||||
#define K_SYSCALL_DEVMUX_SELECT_GET 286
|
||||
#define K_SYSCALL_DEVMUX_SELECT_SET 287
|
||||
#define K_SYSCALL_EEPROM_GET_SIZE 288
|
||||
#define K_SYSCALL_EEPROM_READ 289
|
||||
#define K_SYSCALL_EEPROM_WRITE 290
|
||||
#define K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF 291
|
||||
#define K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING 292
|
||||
#define K_SYSCALL_ENTROPY_GET_ENTROPY 293
|
||||
#define K_SYSCALL_ESPI_CONFIG 294
|
||||
#define K_SYSCALL_ESPI_FLASH_ERASE 295
|
||||
#define K_SYSCALL_ESPI_GET_CHANNEL_STATUS 296
|
||||
#define K_SYSCALL_ESPI_READ_FLASH 297
|
||||
#define K_SYSCALL_ESPI_READ_LPC_REQUEST 298
|
||||
#define K_SYSCALL_ESPI_READ_REQUEST 299
|
||||
#define K_SYSCALL_ESPI_RECEIVE_OOB 300
|
||||
#define K_SYSCALL_ESPI_RECEIVE_VWIRE 301
|
||||
#define K_SYSCALL_ESPI_SAF_ACTIVATE 302
|
||||
#define K_SYSCALL_ESPI_SAF_CONFIG 303
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_ERASE 304
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_READ 305
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS 306
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_WRITE 307
|
||||
#define K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS 308
|
||||
#define K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS 309
|
||||
#define K_SYSCALL_ESPI_SEND_OOB 310
|
||||
#define K_SYSCALL_ESPI_SEND_VWIRE 311
|
||||
#define K_SYSCALL_ESPI_WRITE_FLASH 312
|
||||
#define K_SYSCALL_ESPI_WRITE_LPC_REQUEST 313
|
||||
#define K_SYSCALL_ESPI_WRITE_REQUEST 314
|
||||
#define K_SYSCALL_FLASH_SIMULATOR_GET_MEMORY 315
|
||||
#define K_SYSCALL_FLASH_SIMULATOR_GET_PARAMS 316
|
||||
#define K_SYSCALL_FLASH_SIMULATOR_SET_CALLBACKS 317
|
||||
#define K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF 318
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP 319
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_PROP 320
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_PROPS 321
|
||||
#define K_SYSCALL_FUEL_GAUGE_SET_PROP 322
|
||||
#define K_SYSCALL_FUEL_GAUGE_SET_PROPS 323
|
||||
#define K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS 324
|
||||
#define K_SYSCALL_GNSS_GET_FIX_RATE 325
|
||||
#define K_SYSCALL_GNSS_GET_LATEST_TIMEPULSE 326
|
||||
#define K_SYSCALL_GNSS_GET_NAVIGATION_MODE 327
|
||||
#define K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS 328
|
||||
#define K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS 329
|
||||
#define K_SYSCALL_GNSS_SET_FIX_RATE 330
|
||||
#define K_SYSCALL_GNSS_SET_NAVIGATION_MODE 331
|
||||
#define K_SYSCALL_GPIO_GET_PENDING_INT 332
|
||||
#define K_SYSCALL_GPIO_PIN_CONFIGURE 333
|
||||
#define K_SYSCALL_GPIO_PIN_GET_CONFIG 334
|
||||
#define K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE 335
|
||||
#define K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW 336
|
||||
#define K_SYSCALL_GPIO_PORT_GET_DIRECTION 337
|
||||
#define K_SYSCALL_GPIO_PORT_GET_RAW 338
|
||||
#define K_SYSCALL_GPIO_PORT_SET_BITS_RAW 339
|
||||
#define K_SYSCALL_GPIO_PORT_SET_MASKED_RAW 340
|
||||
#define K_SYSCALL_GPIO_PORT_TOGGLE_BITS 341
|
||||
#define K_SYSCALL_HAPTICS_START_OUTPUT 342
|
||||
#define K_SYSCALL_HAPTICS_STOP_OUTPUT 343
|
||||
#define K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE 344
|
||||
#define K_SYSCALL_HWINFO_GET_DEVICE_EUI64 345
|
||||
#define K_SYSCALL_HWINFO_GET_DEVICE_ID 346
|
||||
#define K_SYSCALL_HWINFO_GET_RESET_CAUSE 347
|
||||
#define K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE 348
|
||||
#define K_SYSCALL_I2C_CONFIGURE 349
|
||||
#define K_SYSCALL_I2C_GET_CONFIG 350
|
||||
#define K_SYSCALL_I2C_RECOVER_BUS 351
|
||||
#define K_SYSCALL_I2C_TARGET_DRIVER_REGISTER 352
|
||||
#define K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER 353
|
||||
#define K_SYSCALL_I2C_TRANSFER 354
|
||||
#define K_SYSCALL_I2S_BUF_READ 355
|
||||
#define K_SYSCALL_I2S_BUF_WRITE 356
|
||||
#define K_SYSCALL_I2S_CONFIGURE 357
|
||||
#define K_SYSCALL_I2S_TRIGGER 358
|
||||
#define K_SYSCALL_I3C_DO_CCC 359
|
||||
#define K_SYSCALL_I3C_DO_CCC_CB 360
|
||||
#define K_SYSCALL_I3C_TRANSFER 361
|
||||
#define K_SYSCALL_I3C_TRANSFER_CB 362
|
||||
#define K_SYSCALL_IPM_COMPLETE 363
|
||||
#define K_SYSCALL_IPM_MAX_DATA_SIZE_GET 364
|
||||
#define K_SYSCALL_IPM_MAX_ID_VAL_GET 365
|
||||
#define K_SYSCALL_IPM_SEND 366
|
||||
#define K_SYSCALL_IPM_SET_ENABLED 367
|
||||
#define K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS 368
|
||||
#define K_SYSCALL_IVSHMEM_GET_ID 369
|
||||
#define K_SYSCALL_IVSHMEM_GET_MAX_PEERS 370
|
||||
#define K_SYSCALL_IVSHMEM_GET_MEM 371
|
||||
#define K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION 372
|
||||
#define K_SYSCALL_IVSHMEM_GET_PROTOCOL 373
|
||||
#define K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION 374
|
||||
#define K_SYSCALL_IVSHMEM_GET_STATE 375
|
||||
#define K_SYSCALL_IVSHMEM_GET_VECTORS 376
|
||||
#define K_SYSCALL_IVSHMEM_INT_PEER 377
|
||||
#define K_SYSCALL_IVSHMEM_REGISTER_HANDLER 378
|
||||
#define K_SYSCALL_IVSHMEM_SET_STATE 379
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET 380
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET 381
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET 382
|
||||
#define K_SYSCALL_K_MEM_PAGING_STATS_GET 383
|
||||
#define K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET 384
|
||||
#define K_SYSCALL_LED_BLINK 385
|
||||
#define K_SYSCALL_LED_GET_INFO 386
|
||||
#define K_SYSCALL_LED_OFF 387
|
||||
#define K_SYSCALL_LED_ON 388
|
||||
#define K_SYSCALL_LED_SET_BRIGHTNESS 389
|
||||
#define K_SYSCALL_LED_SET_CHANNEL 390
|
||||
#define K_SYSCALL_LED_SET_COLOR 391
|
||||
#define K_SYSCALL_LED_WRITE_CHANNELS 392
|
||||
#define K_SYSCALL_LLEXT_GET_FN_TABLE 393
|
||||
#define K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT 394
|
||||
#define K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT 395
|
||||
#define K_SYSCALL_MBOX_MAX_CHANNELS_GET 396
|
||||
#define K_SYSCALL_MBOX_MTU_GET 397
|
||||
#define K_SYSCALL_MBOX_SEND 398
|
||||
#define K_SYSCALL_MBOX_SET_ENABLED 399
|
||||
#define K_SYSCALL_MDIO_READ 400
|
||||
#define K_SYSCALL_MDIO_READ_C45 401
|
||||
#define K_SYSCALL_MDIO_WRITE 402
|
||||
#define K_SYSCALL_MDIO_WRITE_C45 403
|
||||
#define K_SYSCALL_MSPI_CONFIG 404
|
||||
#define K_SYSCALL_MSPI_DEV_CONFIG 405
|
||||
#define K_SYSCALL_MSPI_GET_CHANNEL_STATUS 406
|
||||
#define K_SYSCALL_MSPI_SCRAMBLE_CONFIG 407
|
||||
#define K_SYSCALL_MSPI_TIMING_CONFIG 408
|
||||
#define K_SYSCALL_MSPI_TRANSCEIVE 409
|
||||
#define K_SYSCALL_MSPI_XIP_CONFIG 410
|
||||
#define K_SYSCALL_NET_ADDR_NTOP 411
|
||||
#define K_SYSCALL_NET_ADDR_PTON 412
|
||||
#define K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX 413
|
||||
#define K_SYSCALL_NET_IF_GET_BY_INDEX 414
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_ADD_BY_INDEX 415
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_LOOKUP_BY_INDEX 416
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX 417
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_GW_BY_INDEX 418
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_ADDR_BY_INDEX 419
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_ADD_BY_INDEX 420
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_LOOKUP_BY_INDEX 421
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_RM_BY_INDEX 422
|
||||
#define K_SYSCALL_NET_SOCKET_SERVICE_REGISTER 423
|
||||
#define K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE 424
|
||||
#define K_SYSCALL_OPAMP_SET_GAIN 425
|
||||
#define K_SYSCALL_OTP_PROGRAM 426
|
||||
#define K_SYSCALL_OTP_READ 427
|
||||
#define K_SYSCALL_PECI_CONFIG 428
|
||||
#define K_SYSCALL_PECI_DISABLE 429
|
||||
#define K_SYSCALL_PECI_ENABLE 430
|
||||
#define K_SYSCALL_PECI_TRANSFER 431
|
||||
#define K_SYSCALL_PS2_CONFIG 432
|
||||
#define K_SYSCALL_PS2_DISABLE_CALLBACK 433
|
||||
#define K_SYSCALL_PS2_ENABLE_CALLBACK 434
|
||||
#define K_SYSCALL_PS2_READ 435
|
||||
#define K_SYSCALL_PS2_WRITE 436
|
||||
#define K_SYSCALL_PSI5_REGISTER_CALLBACK 437
|
||||
#define K_SYSCALL_PSI5_SEND 438
|
||||
#define K_SYSCALL_PSI5_START_SYNC 439
|
||||
#define K_SYSCALL_PSI5_STOP_SYNC 440
|
||||
#define K_SYSCALL_PTP_CLOCK_GET 441
|
||||
#define K_SYSCALL_PWM_CAPTURE_CYCLES 442
|
||||
#define K_SYSCALL_PWM_DISABLE_CAPTURE 443
|
||||
#define K_SYSCALL_PWM_ENABLE_CAPTURE 444
|
||||
#define K_SYSCALL_PWM_GET_CYCLES_PER_SEC 445
|
||||
#define K_SYSCALL_PWM_SET_CYCLES 446
|
||||
#define K_SYSCALL_RENESAS_ELC_DISABLE 447
|
||||
#define K_SYSCALL_RENESAS_ELC_ENABLE 448
|
||||
#define K_SYSCALL_RENESAS_ELC_LINK_BREAK 449
|
||||
#define K_SYSCALL_RENESAS_ELC_LINK_SET 450
|
||||
#define K_SYSCALL_RENESAS_ELC_SOFTWARE_EVENT_GENERATE 451
|
||||
#define K_SYSCALL_RENESAS_RA_CTSU_GROUP_CONFIGURE 452
|
||||
#define K_SYSCALL_RENESAS_RX_CTSU_GROUP_CONFIGURE 453
|
||||
#define K_SYSCALL_RESET_LINE_ASSERT 454
|
||||
#define K_SYSCALL_RESET_LINE_DEASSERT 455
|
||||
#define K_SYSCALL_RESET_LINE_TOGGLE 456
|
||||
#define K_SYSCALL_RESET_STATUS 457
|
||||
#define K_SYSCALL_RETAINED_MEM_CLEAR 458
|
||||
#define K_SYSCALL_RETAINED_MEM_READ 459
|
||||
#define K_SYSCALL_RETAINED_MEM_SIZE 460
|
||||
#define K_SYSCALL_RETAINED_MEM_WRITE 461
|
||||
#define K_SYSCALL_RTC_ALARM_GET_SUPPORTED_FIELDS 462
|
||||
#define K_SYSCALL_RTC_ALARM_GET_TIME 463
|
||||
#define K_SYSCALL_RTC_ALARM_IS_PENDING 464
|
||||
#define K_SYSCALL_RTC_ALARM_SET_TIME 465
|
||||
#define K_SYSCALL_RTC_GET_CALIBRATION 466
|
||||
#define K_SYSCALL_RTC_GET_TIME 467
|
||||
#define K_SYSCALL_RTC_SET_CALIBRATION 468
|
||||
#define K_SYSCALL_RTC_SET_TIME 469
|
||||
#define K_SYSCALL_RTIO_CQE_COPY_OUT 470
|
||||
#define K_SYSCALL_RTIO_CQE_GET_MEMPOOL_BUFFER 471
|
||||
#define K_SYSCALL_RTIO_POOL_ACQUIRE 472
|
||||
#define K_SYSCALL_RTIO_POOL_RELEASE 473
|
||||
#define K_SYSCALL_RTIO_RELEASE_BUFFER 474
|
||||
#define K_SYSCALL_RTIO_SQE_CANCEL 475
|
||||
#define K_SYSCALL_RTIO_SQE_COPY_IN_GET_HANDLES 476
|
||||
#define K_SYSCALL_RTIO_SQE_SIGNAL 477
|
||||
#define K_SYSCALL_RTIO_SUBMIT 478
|
||||
#define K_SYSCALL_SDHC_CARD_BUSY 479
|
||||
#define K_SYSCALL_SDHC_CARD_PRESENT 480
|
||||
#define K_SYSCALL_SDHC_DISABLE_INTERRUPT 481
|
||||
#define K_SYSCALL_SDHC_ENABLE_INTERRUPT 482
|
||||
#define K_SYSCALL_SDHC_EXECUTE_TUNING 483
|
||||
#define K_SYSCALL_SDHC_GET_HOST_PROPS 484
|
||||
#define K_SYSCALL_SDHC_HW_RESET 485
|
||||
#define K_SYSCALL_SDHC_REQUEST 486
|
||||
#define K_SYSCALL_SDHC_SET_IO 487
|
||||
#define K_SYSCALL_SENSOR_ATTR_GET 488
|
||||
#define K_SYSCALL_SENSOR_ATTR_SET 489
|
||||
#define K_SYSCALL_SENSOR_CHANNEL_GET 490
|
||||
#define K_SYSCALL_SENSOR_GET_DECODER 491
|
||||
#define K_SYSCALL_SENSOR_RECONFIGURE_READ_IODEV 492
|
||||
#define K_SYSCALL_SENSOR_SAMPLE_FETCH 493
|
||||
#define K_SYSCALL_SENSOR_SAMPLE_FETCH_CHAN 494
|
||||
#define K_SYSCALL_SENT_REGISTER_CALLBACK 495
|
||||
#define K_SYSCALL_SENT_START_LISTENING 496
|
||||
#define K_SYSCALL_SENT_STOP_LISTENING 497
|
||||
#define K_SYSCALL_SIP_SUPERVISORY_CALL 498
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_REQ 499
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_RES 500
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FORMAT_TRANS_ID 501
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FREE_ASYNC_MEMORY 502
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FUNC_ID_VALID 503
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_GET_ERROR_CODE 504
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_GET_TRANS_IDX 505
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_UPDATE_TRANS_ID 506
|
||||
#define K_SYSCALL_SMBUS_BLOCK_PCALL 507
|
||||
#define K_SYSCALL_SMBUS_BLOCK_READ 508
|
||||
#define K_SYSCALL_SMBUS_BLOCK_WRITE 509
|
||||
#define K_SYSCALL_SMBUS_BYTE_DATA_READ 510
|
||||
#define K_SYSCALL_SMBUS_BYTE_DATA_WRITE 511
|
||||
#define K_SYSCALL_SMBUS_BYTE_READ 512
|
||||
#define K_SYSCALL_SMBUS_BYTE_WRITE 513
|
||||
#define K_SYSCALL_SMBUS_CONFIGURE 514
|
||||
#define K_SYSCALL_SMBUS_GET_CONFIG 515
|
||||
#define K_SYSCALL_SMBUS_HOST_NOTIFY_REMOVE_CB 516
|
||||
#define K_SYSCALL_SMBUS_PCALL 517
|
||||
#define K_SYSCALL_SMBUS_QUICK 518
|
||||
#define K_SYSCALL_SMBUS_SMBALERT_REMOVE_CB 519
|
||||
#define K_SYSCALL_SMBUS_WORD_DATA_READ 520
|
||||
#define K_SYSCALL_SMBUS_WORD_DATA_WRITE 521
|
||||
#define K_SYSCALL_SPI_RELEASE 522
|
||||
#define K_SYSCALL_SPI_TRANSCEIVE 523
|
||||
#define K_SYSCALL_STEPPER_CTRL_CONFIGURE_RAMP 524
|
||||
#define K_SYSCALL_STEPPER_CTRL_GET_ACTUAL_POSITION 525
|
||||
#define K_SYSCALL_STEPPER_CTRL_IS_MOVING 526
|
||||
#define K_SYSCALL_STEPPER_CTRL_MOVE_BY 527
|
||||
#define K_SYSCALL_STEPPER_CTRL_MOVE_TO 528
|
||||
#define K_SYSCALL_STEPPER_CTRL_RUN 529
|
||||
#define K_SYSCALL_STEPPER_CTRL_SET_EVENT_CB 530
|
||||
#define K_SYSCALL_STEPPER_CTRL_SET_MICROSTEP_INTERVAL 531
|
||||
#define K_SYSCALL_STEPPER_CTRL_SET_REFERENCE_POSITION 532
|
||||
#define K_SYSCALL_STEPPER_CTRL_STOP 533
|
||||
#define K_SYSCALL_STEPPER_DISABLE 534
|
||||
#define K_SYSCALL_STEPPER_ENABLE 535
|
||||
#define K_SYSCALL_STEPPER_GET_MICRO_STEP_RES 536
|
||||
#define K_SYSCALL_STEPPER_SET_EVENT_CB 537
|
||||
#define K_SYSCALL_STEPPER_SET_MICRO_STEP_RES 538
|
||||
#define K_SYSCALL_SWDP_CONFIGURE 539
|
||||
#define K_SYSCALL_SWDP_GET_PINS 540
|
||||
#define K_SYSCALL_SWDP_INPUT_SEQUENCE 541
|
||||
#define K_SYSCALL_SWDP_OUTPUT_SEQUENCE 542
|
||||
#define K_SYSCALL_SWDP_PORT_OFF 543
|
||||
#define K_SYSCALL_SWDP_PORT_ON 544
|
||||
#define K_SYSCALL_SWDP_SET_CLOCK 545
|
||||
#define K_SYSCALL_SWDP_SET_PINS 546
|
||||
#define K_SYSCALL_SWDP_TRANSFER 547
|
||||
#define K_SYSCALL_SYSCON_GET_BASE 548
|
||||
#define K_SYSCALL_SYSCON_GET_SIZE 549
|
||||
#define K_SYSCALL_SYSCON_READ_REG 550
|
||||
#define K_SYSCALL_SYSCON_UPDATE_BITS 551
|
||||
#define K_SYSCALL_SYSCON_WRITE_REG 552
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE 553
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE 554
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE 555
|
||||
#define K_SYSCALL_SYS_CSRAND_GET 556
|
||||
#define K_SYSCALL_SYS_RAND_GET 557
|
||||
#define K_SYSCALL_TEE_CANCEL 558
|
||||
#define K_SYSCALL_TEE_CLOSE_SESSION 559
|
||||
#define K_SYSCALL_TEE_GET_VERSION 560
|
||||
#define K_SYSCALL_TEE_INVOKE_FUNC 561
|
||||
#define K_SYSCALL_TEE_OPEN_SESSION 562
|
||||
#define K_SYSCALL_TEE_SHM_ALLOC 563
|
||||
#define K_SYSCALL_TEE_SHM_FREE 564
|
||||
#define K_SYSCALL_TEE_SHM_REGISTER 565
|
||||
#define K_SYSCALL_TEE_SHM_UNREGISTER 566
|
||||
#define K_SYSCALL_TEE_SUPPL_RECV 567
|
||||
#define K_SYSCALL_TEE_SUPPL_SEND 568
|
||||
#define K_SYSCALL_TGPIO_PIN_CONFIG_EXT_TIMESTAMP 569
|
||||
#define K_SYSCALL_TGPIO_PIN_DISABLE 570
|
||||
#define K_SYSCALL_TGPIO_PIN_PERIODIC_OUTPUT 571
|
||||
#define K_SYSCALL_TGPIO_PIN_READ_TS_EC 572
|
||||
#define K_SYSCALL_TGPIO_PORT_GET_CYCLES_PER_SECOND 573
|
||||
#define K_SYSCALL_TGPIO_PORT_GET_TIME 574
|
||||
#define K_SYSCALL_UART_CONFIGURE 575
|
||||
#define K_SYSCALL_UART_CONFIG_GET 576
|
||||
#define K_SYSCALL_UART_DRV_CMD 577
|
||||
#define K_SYSCALL_UART_ERR_CHECK 578
|
||||
#define K_SYSCALL_UART_IRQ_ERR_DISABLE 579
|
||||
#define K_SYSCALL_UART_IRQ_ERR_ENABLE 580
|
||||
#define K_SYSCALL_UART_IRQ_IS_PENDING 581
|
||||
#define K_SYSCALL_UART_IRQ_RX_DISABLE 582
|
||||
#define K_SYSCALL_UART_IRQ_RX_ENABLE 583
|
||||
#define K_SYSCALL_UART_IRQ_TX_DISABLE 584
|
||||
#define K_SYSCALL_UART_IRQ_TX_ENABLE 585
|
||||
#define K_SYSCALL_UART_IRQ_UPDATE 586
|
||||
#define K_SYSCALL_UART_LINE_CTRL_GET 587
|
||||
#define K_SYSCALL_UART_LINE_CTRL_SET 588
|
||||
#define K_SYSCALL_UART_POLL_IN 589
|
||||
#define K_SYSCALL_UART_POLL_IN_U16 590
|
||||
#define K_SYSCALL_UART_POLL_OUT 591
|
||||
#define K_SYSCALL_UART_POLL_OUT_U16 592
|
||||
#define K_SYSCALL_UART_RX_DISABLE 593
|
||||
#define K_SYSCALL_UART_RX_ENABLE 594
|
||||
#define K_SYSCALL_UART_RX_ENABLE_U16 595
|
||||
#define K_SYSCALL_UART_TX 596
|
||||
#define K_SYSCALL_UART_TX_ABORT 597
|
||||
#define K_SYSCALL_UART_TX_U16 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_XTENSA_USER_FAULT 620
|
||||
#define K_SYSCALL_ZSOCK_ACCEPT 621
|
||||
#define K_SYSCALL_ZSOCK_BIND 622
|
||||
#define K_SYSCALL_ZSOCK_CLOSE 623
|
||||
#define K_SYSCALL_ZSOCK_CONNECT 624
|
||||
#define K_SYSCALL_ZSOCK_FCNTL_IMPL 625
|
||||
#define K_SYSCALL_ZSOCK_GETHOSTNAME 626
|
||||
#define K_SYSCALL_ZSOCK_GETPEERNAME 627
|
||||
#define K_SYSCALL_ZSOCK_GETSOCKNAME 628
|
||||
#define K_SYSCALL_ZSOCK_GETSOCKOPT 629
|
||||
#define K_SYSCALL_ZSOCK_GET_CONTEXT_OBJECT 630
|
||||
#define K_SYSCALL_ZSOCK_INET_PTON 631
|
||||
#define K_SYSCALL_ZSOCK_IOCTL_IMPL 632
|
||||
#define K_SYSCALL_ZSOCK_LISTEN 633
|
||||
#define K_SYSCALL_ZSOCK_RECVFROM 634
|
||||
#define K_SYSCALL_ZSOCK_RECVMSG 635
|
||||
#define K_SYSCALL_ZSOCK_SENDMSG 636
|
||||
#define K_SYSCALL_ZSOCK_SENDTO 637
|
||||
#define K_SYSCALL_ZSOCK_SETSOCKOPT 638
|
||||
#define K_SYSCALL_ZSOCK_SHUTDOWN 639
|
||||
#define K_SYSCALL_ZSOCK_SOCKET 640
|
||||
#define K_SYSCALL_ZSOCK_SOCKETPAIR 641
|
||||
#define K_SYSCALL_ZVFS_POLL 642
|
||||
#define K_SYSCALL_ZVFS_SELECT 643
|
||||
#define K_SYSCALL_Z_ERRNO 644
|
||||
#define K_SYSCALL_Z_ZSOCK_GETADDRINFO_INTERNAL 645
|
||||
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#endif /* _ASMLANGUAGE */
|
||||
|
||||
#endif /* ZEPHYR_SYSCALL_LIST_H */
|
||||
@@ -1,125 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,52 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,270 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,488 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,173 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,373 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,100 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,812 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,102 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,102 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,98 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,880 +0,0 @@
|
||||
/* 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 uint32_t z_impl_counter_get_pending_int(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t 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 (uint32_t) 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) ({ uint32_t 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
|
||||
|
||||
|
||||
extern int z_impl_counter_enable_capture(const struct device * dev, uint8_t chan_id);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_enable_capture(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_ENABLE_CAPTURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_enable_capture(dev, chan_id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_enable_capture(dev, chan_id) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_ENABLE_CAPTURE, counter_enable_capture, dev, chan_id); syscall__retval = counter_enable_capture(dev, chan_id); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_ENABLE_CAPTURE, counter_enable_capture, dev, chan_id, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_disable_capture(const struct device * dev, uint8_t chan_id);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_disable_capture(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_DISABLE_CAPTURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_disable_capture(dev, chan_id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_disable_capture(dev, chan_id) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_DISABLE_CAPTURE, counter_disable_capture, dev, chan_id); syscall__retval = counter_disable_capture(dev, chan_id); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_DISABLE_CAPTURE, counter_disable_capture, dev, chan_id, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -1,102 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,77 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,298 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,149 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,143 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,75 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,103 +0,0 @@
|
||||
/* 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 */
|
||||
-77
@@ -1,77 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,53 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,43 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,52 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,344 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,218 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,51 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,81 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,408 +0,0 @@
|
||||
/* 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
@@ -1,100 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,179 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,220 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,273 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,74 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,143 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,171 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,128 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,130 +0,0 @@
|
||||
/* 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_do_ccc_cb(const struct device * dev, struct i3c_ccc_payload * payload, i3c_callback_t cb, void * userdata);
|
||||
|
||||
__pinned_func
|
||||
static inline int i3c_do_ccc_cb(const struct device * dev, struct i3c_ccc_payload * payload, i3c_callback_t cb, void * userdata)
|
||||
{
|
||||
#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 };
|
||||
union { uintptr_t x; i3c_callback_t val; } parm2 = { .val = cb };
|
||||
union { uintptr_t x; void * val; } parm3 = { .val = userdata };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_I3C_DO_CCC_CB);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i3c_do_ccc_cb(dev, payload, cb, userdata);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i3c_do_ccc_cb(dev, payload, cb, userdata) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I3C_DO_CCC_CB, i3c_do_ccc_cb, dev, payload, cb, userdata); syscall__retval = i3c_do_ccc_cb(dev, payload, cb, userdata); sys_port_trace_syscall_exit(K_SYSCALL_I3C_DO_CCC_CB, i3c_do_ccc_cb, dev, payload, cb, userdata, 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
|
||||
|
||||
|
||||
extern int z_impl_i3c_transfer_cb(struct i3c_device_desc * target, struct i3c_msg * msgs, uint8_t num_msgs, i3c_callback_t cb, void * userdata);
|
||||
|
||||
__pinned_func
|
||||
static inline int i3c_transfer_cb(struct i3c_device_desc * target, struct i3c_msg * msgs, uint8_t num_msgs, i3c_callback_t cb, void * userdata)
|
||||
{
|
||||
#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 };
|
||||
union { uintptr_t x; i3c_callback_t val; } parm3 = { .val = cb };
|
||||
union { uintptr_t x; void * val; } parm4 = { .val = userdata };
|
||||
return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_I3C_TRANSFER_CB);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i3c_transfer_cb(target, msgs, num_msgs, cb, userdata);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i3c_transfer_cb(target, msgs, num_msgs, cb, userdata) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I3C_TRANSFER_CB, i3c_transfer_cb, target, msgs, num_msgs, cb, userdata); syscall__retval = i3c_transfer_cb(target, msgs, num_msgs, cb, userdata); sys_port_trace_syscall_exit(K_SYSCALL_I3C_TRANSFER_CB, i3c_transfer_cb, target, msgs, num_msgs, cb, userdata, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
-52
@@ -1,52 +0,0 @@
|
||||
/* 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 */
|
||||
-52
@@ -1,52 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,149 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,315 +0,0 @@
|
||||
/* 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 */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,147 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,229 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,126 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,54 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,145 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,136 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,76 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,124 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,134 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,202 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,75 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,246 +0,0 @@
|
||||
/* 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_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 */
|
||||
@@ -1,79 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,53 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,52 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,80 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,122 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,146 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,133 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,52 +0,0 @@
|
||||
/* 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 */
|
||||
@@ -1,160 +0,0 @@
|
||||
/* 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_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 */
|
||||
@@ -1,77 +0,0 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_RANDOM_H
|
||||
#define Z_INCLUDE_SYSCALLS_RANDOM_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_rand_get(void * dst, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline void sys_rand_get(void * dst, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; void * val; } parm0 = { .val = dst };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = len };
|
||||
(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_RAND_GET);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_sys_rand_get(dst, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sys_rand_get(dst, len) do { sys_port_trace_syscall_enter(K_SYSCALL_SYS_RAND_GET, sys_rand_get, dst, len); sys_rand_get(dst, len); sys_port_trace_syscall_exit(K_SYSCALL_SYS_RAND_GET, sys_rand_get, dst, len); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sys_csrand_get(void * dst, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int sys_csrand_get(void * dst, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; void * val; } parm0 = { .val = dst };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = len };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_CSRAND_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sys_csrand_get(dst, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sys_csrand_get(dst, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SYS_CSRAND_GET, sys_csrand_get, dst, len); syscall__retval = sys_csrand_get(dst, len); sys_port_trace_syscall_exit(K_SYSCALL_SYS_CSRAND_GET, sys_csrand_get, dst, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -1,147 +0,0 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_RENESAS_ELC_H
|
||||
#define Z_INCLUDE_SYSCALLS_RENESAS_ELC_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_elc_software_event_generate(const struct device * dev, uint32_t event);
|
||||
|
||||
__pinned_func
|
||||
static inline int renesas_elc_software_event_generate(const struct device * dev, uint32_t event)
|
||||
{
|
||||
#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 = event };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RENESAS_ELC_SOFTWARE_EVENT_GENERATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_renesas_elc_software_event_generate(dev, event);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define renesas_elc_software_event_generate(dev, event) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RENESAS_ELC_SOFTWARE_EVENT_GENERATE, renesas_elc_software_event_generate, dev, event); syscall__retval = renesas_elc_software_event_generate(dev, event); sys_port_trace_syscall_exit(K_SYSCALL_RENESAS_ELC_SOFTWARE_EVENT_GENERATE, renesas_elc_software_event_generate, dev, event, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_renesas_elc_link_set(const struct device * dev, uint32_t peripheral, uint32_t event);
|
||||
|
||||
__pinned_func
|
||||
static inline int renesas_elc_link_set(const struct device * dev, uint32_t peripheral, uint32_t event)
|
||||
{
|
||||
#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 = peripheral };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = event };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_RENESAS_ELC_LINK_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_renesas_elc_link_set(dev, peripheral, event);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define renesas_elc_link_set(dev, peripheral, event) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RENESAS_ELC_LINK_SET, renesas_elc_link_set, dev, peripheral, event); syscall__retval = renesas_elc_link_set(dev, peripheral, event); sys_port_trace_syscall_exit(K_SYSCALL_RENESAS_ELC_LINK_SET, renesas_elc_link_set, dev, peripheral, event, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_renesas_elc_link_break(const struct device * dev, uint32_t peripheral);
|
||||
|
||||
__pinned_func
|
||||
static inline int renesas_elc_link_break(const struct device * dev, uint32_t peripheral)
|
||||
{
|
||||
#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 = peripheral };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RENESAS_ELC_LINK_BREAK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_renesas_elc_link_break(dev, peripheral);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define renesas_elc_link_break(dev, peripheral) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RENESAS_ELC_LINK_BREAK, renesas_elc_link_break, dev, peripheral); syscall__retval = renesas_elc_link_break(dev, peripheral); sys_port_trace_syscall_exit(K_SYSCALL_RENESAS_ELC_LINK_BREAK, renesas_elc_link_break, dev, peripheral, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_renesas_elc_enable(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int renesas_elc_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_RENESAS_ELC_ENABLE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_renesas_elc_enable(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define renesas_elc_enable(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RENESAS_ELC_ENABLE, renesas_elc_enable, dev); syscall__retval = renesas_elc_enable(dev); sys_port_trace_syscall_exit(K_SYSCALL_RENESAS_ELC_ENABLE, renesas_elc_enable, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_renesas_elc_disable(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int renesas_elc_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_RENESAS_ELC_DISABLE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_renesas_elc_disable(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define renesas_elc_disable(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RENESAS_ELC_DISABLE, renesas_elc_disable, dev); syscall__retval = renesas_elc_disable(dev); sys_port_trace_syscall_exit(K_SYSCALL_RENESAS_ELC_DISABLE, renesas_elc_disable, dev, 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