feat: working basic firmware with legacy USB API
- Successful compilation with Zephyr 4.3.0 - Basic gs_usb USB interface implementation - CAN-FD support with FDCAN2 interface - PFET control via UART (simplified from USB CDC) - Custom board definition for STM32G0B1KBU6 - Deprecated warnings present but functional - Memory usage: 51KB Flash (9.8%), 21.6KB RAM (14.7%) Next: Migrate to new USB device stack API to remove warnings
This commit is contained in:
@@ -0,0 +1,9 @@
|
||||
/*
|
||||
* Copyright (c) 2017 Linaro Limited.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/* Set initial alignment to the 32 byte minimum for all MPUs */
|
||||
_app_data_align = 32;
|
||||
. = ALIGN(32);
|
||||
@@ -0,0 +1,38 @@
|
||||
/* SPDX-License-Identifier: Apache-2.0 */
|
||||
|
||||
/*
|
||||
* This hackish way of including files is due to CMake issues:
|
||||
* https://gitlab.kitware.com/cmake/cmake/issues/11985
|
||||
* https://gitlab.kitware.com/cmake/cmake/issues/13718
|
||||
*
|
||||
* When using the "Unix Makefiles" generator, CMake simply
|
||||
* greps for "#include" to generate dependency list.
|
||||
* So if doing it normally, both files are being included
|
||||
* in the dependency list. This creates weird dependency
|
||||
* issue:
|
||||
*
|
||||
* 1. Using A.ld to create a linker script A.cmd.
|
||||
* 2. Using A.cmd to generate A_prebuilt.elf.
|
||||
* 3. Using A_prebuilt.elf to create B.ld.
|
||||
* 4. Creating B.cmd with B.ld.
|
||||
* 5. Creating B_prebuilt.elf using B.cmd.
|
||||
*
|
||||
* Since the dependency list of A.cmd contains both
|
||||
* A.ld and B.ld, when make is invoked again, B.ld
|
||||
* is newer than A.cmd so everything from this point on
|
||||
* gets rebuilt. In order to break this cycle, this
|
||||
* hackish needs to be used since CMake does not parse
|
||||
* macros, and thus these will not appear in
|
||||
* the dependency list. The dependencies should then be
|
||||
* put in CMakeLists.txt instead.
|
||||
*
|
||||
* Note: Ninja generator does not suffer from this issue.
|
||||
*/
|
||||
#ifdef LINKER_APP_SMEM_UNALIGNED
|
||||
#define APP_SMEM_LD <app_smem_unaligned.ld>
|
||||
#else
|
||||
#define APP_SMEM_LD <app_smem_aligned.ld>
|
||||
#endif
|
||||
|
||||
#include APP_SMEM_LD
|
||||
#undef APP_SMEM_LD
|
||||
@@ -0,0 +1,3 @@
|
||||
/* SPDX-License-Identifier: Apache-2.0 */
|
||||
|
||||
/* Empty file */
|
||||
@@ -0,0 +1,3 @@
|
||||
/* SPDX-License-Identifier: Apache-2.0 */
|
||||
|
||||
/* Empty file */
|
||||
@@ -0,0 +1,176 @@
|
||||
list(APPEND sections "{NAME\;can_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;can_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._can_driver_api.static.*\;SYMBOLS\;_can_driver_api_list_start\;_can_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;gpio_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;gpio_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._gpio_driver_api.static.*\;SYMBOLS\;_gpio_driver_api_list_start\;_gpio_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;reset_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;reset_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._reset_driver_api.static.*\;SYMBOLS\;_reset_driver_api_list_start\;_reset_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;shared_irq_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;shared_irq_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._shared_irq_driver_api.static.*\;SYMBOLS\;_shared_irq_driver_api_list_start\;_shared_irq_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;crypto_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;crypto_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._crypto_driver_api.static.*\;SYMBOLS\;_crypto_driver_api_list_start\;_crypto_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;adc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;adc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._adc_driver_api.static.*\;SYMBOLS\;_adc_driver_api_list_start\;_adc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;auxdisplay_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;auxdisplay_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._auxdisplay_driver_api.static.*\;SYMBOLS\;_auxdisplay_driver_api_list_start\;_auxdisplay_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;bbram_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;bbram_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._bbram_driver_api.static.*\;SYMBOLS\;_bbram_driver_api_list_start\;_bbram_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;bt_hci_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;bt_hci_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._bt_hci_driver_api.static.*\;SYMBOLS\;_bt_hci_driver_api_list_start\;_bt_hci_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;cellular_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;cellular_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._cellular_driver_api.static.*\;SYMBOLS\;_cellular_driver_api_list_start\;_cellular_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;charger_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;charger_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._charger_driver_api.static.*\;SYMBOLS\;_charger_driver_api_list_start\;_charger_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;clock_control_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;clock_control_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._clock_control_driver_api.static.*\;SYMBOLS\;_clock_control_driver_api_list_start\;_clock_control_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;comparator_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;comparator_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._comparator_driver_api.static.*\;SYMBOLS\;_comparator_driver_api_list_start\;_comparator_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;coredump_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;coredump_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._coredump_driver_api.static.*\;SYMBOLS\;_coredump_driver_api_list_start\;_coredump_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;counter_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;counter_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._counter_driver_api.static.*\;SYMBOLS\;_counter_driver_api_list_start\;_counter_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;crc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;crc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._crc_driver_api.static.*\;SYMBOLS\;_crc_driver_api_list_start\;_crc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;dac_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;dac_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._dac_driver_api.static.*\;SYMBOLS\;_dac_driver_api_list_start\;_dac_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;dai_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;dai_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._dai_driver_api.static.*\;SYMBOLS\;_dai_driver_api_list_start\;_dai_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;display_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;display_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._display_driver_api.static.*\;SYMBOLS\;_display_driver_api_list_start\;_display_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;dma_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;dma_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._dma_driver_api.static.*\;SYMBOLS\;_dma_driver_api_list_start\;_dma_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;edac_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;edac_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._edac_driver_api.static.*\;SYMBOLS\;_edac_driver_api_list_start\;_edac_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;eeprom_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;eeprom_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._eeprom_driver_api.static.*\;SYMBOLS\;_eeprom_driver_api_list_start\;_eeprom_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;emul_bbram_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;emul_bbram_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._emul_bbram_driver_api.static.*\;SYMBOLS\;_emul_bbram_driver_api_list_start\;_emul_bbram_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;fuel_gauge_emul_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;fuel_gauge_emul_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._fuel_gauge_emul_driver_api.static.*\;SYMBOLS\;_fuel_gauge_emul_driver_api_list_start\;_fuel_gauge_emul_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;emul_sensor_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;emul_sensor_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._emul_sensor_driver_api.static.*\;SYMBOLS\;_emul_sensor_driver_api_list_start\;_emul_sensor_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;entropy_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;entropy_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._entropy_driver_api.static.*\;SYMBOLS\;_entropy_driver_api_list_start\;_entropy_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;espi_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;espi_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._espi_driver_api.static.*\;SYMBOLS\;_espi_driver_api_list_start\;_espi_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;espi_saf_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;espi_saf_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._espi_saf_driver_api.static.*\;SYMBOLS\;_espi_saf_driver_api_list_start\;_espi_saf_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;flash_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;flash_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._flash_driver_api.static.*\;SYMBOLS\;_flash_driver_api_list_start\;_flash_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;fpga_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;fpga_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._fpga_driver_api.static.*\;SYMBOLS\;_fpga_driver_api_list_start\;_fpga_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;fuel_gauge_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;fuel_gauge_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._fuel_gauge_driver_api.static.*\;SYMBOLS\;_fuel_gauge_driver_api_list_start\;_fuel_gauge_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;gnss_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;gnss_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._gnss_driver_api.static.*\;SYMBOLS\;_gnss_driver_api_list_start\;_gnss_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;haptics_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;haptics_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._haptics_driver_api.static.*\;SYMBOLS\;_haptics_driver_api_list_start\;_haptics_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;hwspinlock_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;hwspinlock_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._hwspinlock_driver_api.static.*\;SYMBOLS\;_hwspinlock_driver_api_list_start\;_hwspinlock_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;i2c_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;i2c_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._i2c_driver_api.static.*\;SYMBOLS\;_i2c_driver_api_list_start\;_i2c_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;i2c_target_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;i2c_target_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._i2c_target_driver_api.static.*\;SYMBOLS\;_i2c_target_driver_api_list_start\;_i2c_target_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;i2s_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;i2s_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._i2s_driver_api.static.*\;SYMBOLS\;_i2s_driver_api_list_start\;_i2s_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;i3c_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;i3c_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._i3c_driver_api.static.*\;SYMBOLS\;_i3c_driver_api_list_start\;_i3c_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;ipm_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;ipm_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._ipm_driver_api.static.*\;SYMBOLS\;_ipm_driver_api_list_start\;_ipm_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;led_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;led_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._led_driver_api.static.*\;SYMBOLS\;_led_driver_api_list_start\;_led_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;led_strip_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;led_strip_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._led_strip_driver_api.static.*\;SYMBOLS\;_led_strip_driver_api_list_start\;_led_strip_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;lora_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;lora_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._lora_driver_api.static.*\;SYMBOLS\;_lora_driver_api_list_start\;_lora_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;mbox_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;mbox_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._mbox_driver_api.static.*\;SYMBOLS\;_mbox_driver_api_list_start\;_mbox_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;mdio_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;mdio_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._mdio_driver_api.static.*\;SYMBOLS\;_mdio_driver_api_list_start\;_mdio_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;mipi_dbi_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;mipi_dbi_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._mipi_dbi_driver_api.static.*\;SYMBOLS\;_mipi_dbi_driver_api_list_start\;_mipi_dbi_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;mipi_dsi_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;mipi_dsi_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._mipi_dsi_driver_api.static.*\;SYMBOLS\;_mipi_dsi_driver_api_list_start\;_mipi_dsi_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;mspi_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;mspi_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._mspi_driver_api.static.*\;SYMBOLS\;_mspi_driver_api_list_start\;_mspi_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;opamp_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;opamp_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._opamp_driver_api.static.*\;SYMBOLS\;_opamp_driver_api_list_start\;_opamp_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;peci_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;peci_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._peci_driver_api.static.*\;SYMBOLS\;_peci_driver_api_list_start\;_peci_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;ps2_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;ps2_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._ps2_driver_api.static.*\;SYMBOLS\;_ps2_driver_api_list_start\;_ps2_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;ptp_clock_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;ptp_clock_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._ptp_clock_driver_api.static.*\;SYMBOLS\;_ptp_clock_driver_api_list_start\;_ptp_clock_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;pwm_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;pwm_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._pwm_driver_api.static.*\;SYMBOLS\;_pwm_driver_api_list_start\;_pwm_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;regulator_parent_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;regulator_parent_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._regulator_parent_driver_api.static.*\;SYMBOLS\;_regulator_parent_driver_api_list_start\;_regulator_parent_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;regulator_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;regulator_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._regulator_driver_api.static.*\;SYMBOLS\;_regulator_driver_api_list_start\;_regulator_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;retained_mem_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;retained_mem_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._retained_mem_driver_api.static.*\;SYMBOLS\;_retained_mem_driver_api_list_start\;_retained_mem_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;rtc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;rtc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._rtc_driver_api.static.*\;SYMBOLS\;_rtc_driver_api_list_start\;_rtc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;sdhc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;sdhc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._sdhc_driver_api.static.*\;SYMBOLS\;_sdhc_driver_api_list_start\;_sdhc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;sensor_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;sensor_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._sensor_driver_api.static.*\;SYMBOLS\;_sensor_driver_api_list_start\;_sensor_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;smbus_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;smbus_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._smbus_driver_api.static.*\;SYMBOLS\;_smbus_driver_api_list_start\;_smbus_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;spi_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;spi_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._spi_driver_api.static.*\;SYMBOLS\;_spi_driver_api_list_start\;_spi_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;stepper_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;stepper_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._stepper_driver_api.static.*\;SYMBOLS\;_stepper_driver_api_list_start\;_stepper_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;syscon_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;syscon_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._syscon_driver_api.static.*\;SYMBOLS\;_syscon_driver_api_list_start\;_syscon_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;tee_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;tee_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._tee_driver_api.static.*\;SYMBOLS\;_tee_driver_api_list_start\;_tee_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;video_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;video_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._video_driver_api.static.*\;SYMBOLS\;_video_driver_api_list_start\;_video_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;virtio_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;virtio_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._virtio_driver_api.static.*\;SYMBOLS\;_virtio_driver_api_list_start\;_virtio_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;w1_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;w1_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._w1_driver_api.static.*\;SYMBOLS\;_w1_driver_api_list_start\;_w1_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;wdt_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;wdt_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._wdt_driver_api.static.*\;SYMBOLS\;_wdt_driver_api_list_start\;_wdt_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;can_transceiver_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;can_transceiver_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._can_transceiver_driver_api.static.*\;SYMBOLS\;_can_transceiver_driver_api_list_start\;_can_transceiver_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;nrf_clock_control_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;nrf_clock_control_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._nrf_clock_control_driver_api.static.*\;SYMBOLS\;_nrf_clock_control_driver_api_list_start\;_nrf_clock_control_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;i3c_target_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;i3c_target_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._i3c_target_driver_api.static.*\;SYMBOLS\;_i3c_target_driver_api_list_start\;_i3c_target_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;its_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;its_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._its_driver_api.static.*\;SYMBOLS\;_its_driver_api_list_start\;_its_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;vtd_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;vtd_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._vtd_driver_api.static.*\;SYMBOLS\;_vtd_driver_api_list_start\;_vtd_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;renesas_elc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;renesas_elc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._renesas_elc_driver_api.static.*\;SYMBOLS\;_renesas_elc_driver_api_list_start\;_renesas_elc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;tgpio_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;tgpio_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._tgpio_driver_api.static.*\;SYMBOLS\;_tgpio_driver_api_list_start\;_tgpio_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;pcie_ctrl_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;pcie_ctrl_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._pcie_ctrl_driver_api.static.*\;SYMBOLS\;_pcie_ctrl_driver_api_list_start\;_pcie_ctrl_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;pcie_ep_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;pcie_ep_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._pcie_ep_driver_api.static.*\;SYMBOLS\;_pcie_ep_driver_api_list_start\;_pcie_ep_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;psi5_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;psi5_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._psi5_driver_api.static.*\;SYMBOLS\;_psi5_driver_api_list_start\;_psi5_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;sent_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;sent_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._sent_driver_api.static.*\;SYMBOLS\;_sent_driver_api_list_start\;_sent_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;svc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;svc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._svc_driver_api.static.*\;SYMBOLS\;_svc_driver_api_list_start\;_svc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;uart_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;uart_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._uart_driver_api.static.*\;SYMBOLS\;_uart_driver_api_list_start\;_uart_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;bc12_emul_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;bc12_emul_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._bc12_emul_driver_api.static.*\;SYMBOLS\;_bc12_emul_driver_api_list_start\;_bc12_emul_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;bc12_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;bc12_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._bc12_driver_api.static.*\;SYMBOLS\;_bc12_driver_api_list_start\;_bc12_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;usbc_ppc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;usbc_ppc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._usbc_ppc_driver_api.static.*\;SYMBOLS\;_usbc_ppc_driver_api_list_start\;_usbc_ppc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;tcpc_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;tcpc_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._tcpc_driver_api.static.*\;SYMBOLS\;_tcpc_driver_api_list_start\;_tcpc_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;usbc_vbus_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;usbc_vbus_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._usbc_vbus_driver_api.static.*\;SYMBOLS\;_usbc_vbus_driver_api_list_start\;_usbc_vbus_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;ivshmem_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;ivshmem_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._ivshmem_driver_api.static.*\;SYMBOLS\;_ivshmem_driver_api_list_start\;_ivshmem_driver_api_list_end}")
|
||||
list(APPEND sections "{NAME\;ethphy_driver_api_area\;GROUP\;RODATA_REGION\;SUBALIGN\;4\;NOINPUT\;TRUE}")
|
||||
list(APPEND section_settings "{SECTION\;ethphy_driver_api_area\;SORT\;NAME\;KEEP\;TRUE\;INPUT\;._ethphy_driver_api.static.*\;SYMBOLS\;_ethphy_driver_api_list_start\;_ethphy_driver_api_list_end}")
|
||||
set(DEVICE_API_SECTIONS "${sections}" CACHE INTERNAL "")
|
||||
set(DEVICE_API_SECTION_SETTINGS "${section_settings}" CACHE INTERNAL "")
|
||||
@@ -0,0 +1,87 @@
|
||||
ITERABLE_SECTION_ROM(can_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(gpio_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(reset_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(shared_irq_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(crypto_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(adc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(auxdisplay_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(bbram_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(bt_hci_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(cellular_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(charger_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(clock_control_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(comparator_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(coredump_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(counter_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(crc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(dac_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(dai_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(display_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(dma_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(edac_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(eeprom_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(emul_bbram_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(fuel_gauge_emul_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(emul_sensor_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(entropy_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(espi_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(espi_saf_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(flash_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(fpga_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(fuel_gauge_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(gnss_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(haptics_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(hwspinlock_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(i2c_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(i2c_target_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(i2s_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(i3c_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(ipm_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(led_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(led_strip_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(lora_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(mbox_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(mdio_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(mipi_dbi_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(mipi_dsi_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(mspi_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(opamp_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(peci_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(ps2_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(ptp_clock_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(pwm_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(regulator_parent_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(regulator_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(retained_mem_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(rtc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(sdhc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(sensor_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(smbus_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(spi_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(stepper_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(syscon_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(tee_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(video_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(virtio_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(w1_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(wdt_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(can_transceiver_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(nrf_clock_control_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(i3c_target_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(its_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(vtd_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(renesas_elc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(tgpio_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(pcie_ctrl_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(pcie_ep_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(psi5_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(sent_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(svc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(uart_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(bc12_emul_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(bc12_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(usbc_ppc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(tcpc_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(usbc_vbus_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(ivshmem_driver_api, 4)
|
||||
ITERABLE_SECTION_ROM(ethphy_driver_api, 4)
|
||||
@@ -0,0 +1 @@
|
||||
/* Sort key: "default" */#include "../arch/common/ramfunc.ld"
|
||||
@@ -0,0 +1 @@
|
||||
/* Sort key: "default" */#include "../arch/arm/core/swi_tables.ld"
|
||||
@@ -0,0 +1,6 @@
|
||||
/* 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"
|
||||
@@ -0,0 +1 @@
|
||||
/* Sort key: "default" */#include "zephyr/linker/intlist.ld"
|
||||
@@ -0,0 +1,604 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef ZEPHYR_SYSCALL_LIST_H
|
||||
#define ZEPHYR_SYSCALL_LIST_H
|
||||
|
||||
#define K_SYSCALL_ATOMIC_ADD 0
|
||||
#define K_SYSCALL_ATOMIC_AND 1
|
||||
#define K_SYSCALL_ATOMIC_CAS 2
|
||||
#define K_SYSCALL_ATOMIC_NAND 3
|
||||
#define K_SYSCALL_ATOMIC_OR 4
|
||||
#define K_SYSCALL_ATOMIC_PTR_CAS 5
|
||||
#define K_SYSCALL_ATOMIC_PTR_SET 6
|
||||
#define K_SYSCALL_ATOMIC_SET 7
|
||||
#define K_SYSCALL_ATOMIC_SUB 8
|
||||
#define K_SYSCALL_ATOMIC_XOR 9
|
||||
#define K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ 10
|
||||
#define K_SYSCALL_CAN_CALC_TIMING 11
|
||||
#define K_SYSCALL_CAN_CALC_TIMING_DATA 12
|
||||
#define K_SYSCALL_CAN_GET_BITRATE_MAX 13
|
||||
#define K_SYSCALL_CAN_GET_BITRATE_MIN 14
|
||||
#define K_SYSCALL_CAN_GET_CAPABILITIES 15
|
||||
#define K_SYSCALL_CAN_GET_CORE_CLOCK 16
|
||||
#define K_SYSCALL_CAN_GET_MAX_FILTERS 17
|
||||
#define K_SYSCALL_CAN_GET_MODE 18
|
||||
#define K_SYSCALL_CAN_GET_STATE 19
|
||||
#define K_SYSCALL_CAN_GET_TIMING_DATA_MAX 20
|
||||
#define K_SYSCALL_CAN_GET_TIMING_DATA_MIN 21
|
||||
#define K_SYSCALL_CAN_GET_TIMING_MAX 22
|
||||
#define K_SYSCALL_CAN_GET_TIMING_MIN 23
|
||||
#define K_SYSCALL_CAN_GET_TRANSCEIVER 24
|
||||
#define K_SYSCALL_CAN_RECOVER 25
|
||||
#define K_SYSCALL_CAN_REMOVE_RX_FILTER 26
|
||||
#define K_SYSCALL_CAN_SEND 27
|
||||
#define K_SYSCALL_CAN_SET_BITRATE 28
|
||||
#define K_SYSCALL_CAN_SET_BITRATE_DATA 29
|
||||
#define K_SYSCALL_CAN_SET_MODE 30
|
||||
#define K_SYSCALL_CAN_SET_TIMING 31
|
||||
#define K_SYSCALL_CAN_SET_TIMING_DATA 32
|
||||
#define K_SYSCALL_CAN_START 33
|
||||
#define K_SYSCALL_CAN_STATS_GET_ACK_ERRORS 34
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS 35
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS 36
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT_ERRORS 37
|
||||
#define K_SYSCALL_CAN_STATS_GET_CRC_ERRORS 38
|
||||
#define K_SYSCALL_CAN_STATS_GET_FORM_ERRORS 39
|
||||
#define K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS 40
|
||||
#define K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS 41
|
||||
#define K_SYSCALL_CAN_STOP 42
|
||||
#define K_SYSCALL_DEVICE_DEINIT 43
|
||||
#define K_SYSCALL_DEVICE_GET_BINDING 44
|
||||
#define K_SYSCALL_DEVICE_GET_BY_DT_NODELABEL 45
|
||||
#define K_SYSCALL_DEVICE_INIT 46
|
||||
#define K_SYSCALL_DEVICE_IS_READY 47
|
||||
#define K_SYSCALL_GPIO_GET_PENDING_INT 48
|
||||
#define K_SYSCALL_GPIO_PIN_CONFIGURE 49
|
||||
#define K_SYSCALL_GPIO_PIN_GET_CONFIG 50
|
||||
#define K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE 51
|
||||
#define K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW 52
|
||||
#define K_SYSCALL_GPIO_PORT_GET_DIRECTION 53
|
||||
#define K_SYSCALL_GPIO_PORT_GET_RAW 54
|
||||
#define K_SYSCALL_GPIO_PORT_SET_BITS_RAW 55
|
||||
#define K_SYSCALL_GPIO_PORT_SET_MASKED_RAW 56
|
||||
#define K_SYSCALL_GPIO_PORT_TOGGLE_BITS 57
|
||||
#define K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE 58
|
||||
#define K_SYSCALL_HWINFO_GET_DEVICE_EUI64 59
|
||||
#define K_SYSCALL_HWINFO_GET_DEVICE_ID 60
|
||||
#define K_SYSCALL_HWINFO_GET_RESET_CAUSE 61
|
||||
#define K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE 62
|
||||
#define K_SYSCALL_K_BUSY_WAIT 63
|
||||
#define K_SYSCALL_K_CONDVAR_BROADCAST 64
|
||||
#define K_SYSCALL_K_CONDVAR_INIT 65
|
||||
#define K_SYSCALL_K_CONDVAR_SIGNAL 66
|
||||
#define K_SYSCALL_K_CONDVAR_WAIT 67
|
||||
#define K_SYSCALL_K_EVENT_CLEAR 68
|
||||
#define K_SYSCALL_K_EVENT_INIT 69
|
||||
#define K_SYSCALL_K_EVENT_POST 70
|
||||
#define K_SYSCALL_K_EVENT_SET 71
|
||||
#define K_SYSCALL_K_EVENT_SET_MASKED 72
|
||||
#define K_SYSCALL_K_EVENT_WAIT 73
|
||||
#define K_SYSCALL_K_EVENT_WAIT_ALL 74
|
||||
#define K_SYSCALL_K_EVENT_WAIT_ALL_SAFE 75
|
||||
#define K_SYSCALL_K_EVENT_WAIT_SAFE 76
|
||||
#define K_SYSCALL_K_FLOAT_DISABLE 77
|
||||
#define K_SYSCALL_K_FLOAT_ENABLE 78
|
||||
#define K_SYSCALL_K_FUTEX_WAIT 79
|
||||
#define K_SYSCALL_K_FUTEX_WAKE 80
|
||||
#define K_SYSCALL_K_IS_PREEMPT_THREAD 81
|
||||
#define K_SYSCALL_K_MSGQ_ALLOC_INIT 82
|
||||
#define K_SYSCALL_K_MSGQ_GET 83
|
||||
#define K_SYSCALL_K_MSGQ_GET_ATTRS 84
|
||||
#define K_SYSCALL_K_MSGQ_NUM_FREE_GET 85
|
||||
#define K_SYSCALL_K_MSGQ_NUM_USED_GET 86
|
||||
#define K_SYSCALL_K_MSGQ_PEEK 87
|
||||
#define K_SYSCALL_K_MSGQ_PEEK_AT 88
|
||||
#define K_SYSCALL_K_MSGQ_PURGE 89
|
||||
#define K_SYSCALL_K_MSGQ_PUT 90
|
||||
#define K_SYSCALL_K_MSGQ_PUT_FRONT 91
|
||||
#define K_SYSCALL_K_MUTEX_INIT 92
|
||||
#define K_SYSCALL_K_MUTEX_LOCK 93
|
||||
#define K_SYSCALL_K_MUTEX_UNLOCK 94
|
||||
#define K_SYSCALL_K_OBJECT_ACCESS_GRANT 95
|
||||
#define K_SYSCALL_K_OBJECT_ALLOC 96
|
||||
#define K_SYSCALL_K_OBJECT_ALLOC_SIZE 97
|
||||
#define K_SYSCALL_K_OBJECT_RELEASE 98
|
||||
#define K_SYSCALL_K_PIPE_CLOSE 99
|
||||
#define K_SYSCALL_K_PIPE_INIT 100
|
||||
#define K_SYSCALL_K_PIPE_READ 101
|
||||
#define K_SYSCALL_K_PIPE_RESET 102
|
||||
#define K_SYSCALL_K_PIPE_WRITE 103
|
||||
#define K_SYSCALL_K_POLL 104
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_CHECK 105
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_INIT 106
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_RAISE 107
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_RESET 108
|
||||
#define K_SYSCALL_K_QUEUE_ALLOC_APPEND 109
|
||||
#define K_SYSCALL_K_QUEUE_ALLOC_PREPEND 110
|
||||
#define K_SYSCALL_K_QUEUE_CANCEL_WAIT 111
|
||||
#define K_SYSCALL_K_QUEUE_GET 112
|
||||
#define K_SYSCALL_K_QUEUE_INIT 113
|
||||
#define K_SYSCALL_K_QUEUE_IS_EMPTY 114
|
||||
#define K_SYSCALL_K_QUEUE_PEEK_HEAD 115
|
||||
#define K_SYSCALL_K_QUEUE_PEEK_TAIL 116
|
||||
#define K_SYSCALL_K_RESCHEDULE 117
|
||||
#define K_SYSCALL_K_SCHED_CURRENT_THREAD_QUERY 118
|
||||
#define K_SYSCALL_K_SEM_COUNT_GET 119
|
||||
#define K_SYSCALL_K_SEM_GIVE 120
|
||||
#define K_SYSCALL_K_SEM_INIT 121
|
||||
#define K_SYSCALL_K_SEM_RESET 122
|
||||
#define K_SYSCALL_K_SEM_TAKE 123
|
||||
#define K_SYSCALL_K_SLEEP 124
|
||||
#define K_SYSCALL_K_STACK_ALLOC_INIT 125
|
||||
#define K_SYSCALL_K_STACK_POP 126
|
||||
#define K_SYSCALL_K_STACK_PUSH 127
|
||||
#define K_SYSCALL_K_STR_OUT 128
|
||||
#define K_SYSCALL_K_THREAD_ABORT 129
|
||||
#define K_SYSCALL_K_THREAD_ABSOLUTE_DEADLINE_SET 130
|
||||
#define K_SYSCALL_K_THREAD_CREATE 131
|
||||
#define K_SYSCALL_K_THREAD_CUSTOM_DATA_GET 132
|
||||
#define K_SYSCALL_K_THREAD_CUSTOM_DATA_SET 133
|
||||
#define K_SYSCALL_K_THREAD_DEADLINE_SET 134
|
||||
#define K_SYSCALL_K_THREAD_JOIN 135
|
||||
#define K_SYSCALL_K_THREAD_NAME_COPY 136
|
||||
#define K_SYSCALL_K_THREAD_NAME_SET 137
|
||||
#define K_SYSCALL_K_THREAD_PRIORITY_GET 138
|
||||
#define K_SYSCALL_K_THREAD_PRIORITY_SET 139
|
||||
#define K_SYSCALL_K_THREAD_RESUME 140
|
||||
#define K_SYSCALL_K_THREAD_STACK_ALLOC 141
|
||||
#define K_SYSCALL_K_THREAD_STACK_FREE 142
|
||||
#define K_SYSCALL_K_THREAD_STACK_SPACE_GET 143
|
||||
#define K_SYSCALL_K_THREAD_SUSPEND 144
|
||||
#define K_SYSCALL_K_THREAD_TIMEOUT_EXPIRES_TICKS 145
|
||||
#define K_SYSCALL_K_THREAD_TIMEOUT_REMAINING_TICKS 146
|
||||
#define K_SYSCALL_K_TIMER_EXPIRES_TICKS 147
|
||||
#define K_SYSCALL_K_TIMER_REMAINING_TICKS 148
|
||||
#define K_SYSCALL_K_TIMER_START 149
|
||||
#define K_SYSCALL_K_TIMER_STATUS_GET 150
|
||||
#define K_SYSCALL_K_TIMER_STATUS_SYNC 151
|
||||
#define K_SYSCALL_K_TIMER_STOP 152
|
||||
#define K_SYSCALL_K_TIMER_USER_DATA_GET 153
|
||||
#define K_SYSCALL_K_TIMER_USER_DATA_SET 154
|
||||
#define K_SYSCALL_K_UPTIME_TICKS 155
|
||||
#define K_SYSCALL_K_USLEEP 156
|
||||
#define K_SYSCALL_K_WAKEUP 157
|
||||
#define K_SYSCALL_K_YIELD 158
|
||||
#define K_SYSCALL_LOG_BUFFERED_CNT 159
|
||||
#define K_SYSCALL_LOG_FILTER_SET 160
|
||||
#define K_SYSCALL_LOG_FRONTEND_FILTER_SET 161
|
||||
#define K_SYSCALL_LOG_PANIC 162
|
||||
#define K_SYSCALL_LOG_PROCESS 163
|
||||
#define K_SYSCALL_RESET_LINE_ASSERT 164
|
||||
#define K_SYSCALL_RESET_LINE_DEASSERT 165
|
||||
#define K_SYSCALL_RESET_LINE_TOGGLE 166
|
||||
#define K_SYSCALL_RESET_STATUS 167
|
||||
#define K_SYSCALL_SYS_CLOCK_GETRTOFFSET 168
|
||||
#define K_SYSCALL_SYS_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_GET 169
|
||||
#define K_SYSCALL_SYS_CLOCK_NANOSLEEP 170
|
||||
#define K_SYSCALL_SYS_CLOCK_SETTIME 171
|
||||
#define K_SYSCALL_UART_CONFIGURE 172
|
||||
#define K_SYSCALL_UART_CONFIG_GET 173
|
||||
#define K_SYSCALL_UART_DRV_CMD 174
|
||||
#define K_SYSCALL_UART_ERR_CHECK 175
|
||||
#define K_SYSCALL_UART_IRQ_ERR_DISABLE 176
|
||||
#define K_SYSCALL_UART_IRQ_ERR_ENABLE 177
|
||||
#define K_SYSCALL_UART_IRQ_IS_PENDING 178
|
||||
#define K_SYSCALL_UART_IRQ_RX_DISABLE 179
|
||||
#define K_SYSCALL_UART_IRQ_RX_ENABLE 180
|
||||
#define K_SYSCALL_UART_IRQ_TX_DISABLE 181
|
||||
#define K_SYSCALL_UART_IRQ_TX_ENABLE 182
|
||||
#define K_SYSCALL_UART_IRQ_UPDATE 183
|
||||
#define K_SYSCALL_UART_LINE_CTRL_GET 184
|
||||
#define K_SYSCALL_UART_LINE_CTRL_SET 185
|
||||
#define K_SYSCALL_UART_POLL_IN 186
|
||||
#define K_SYSCALL_UART_POLL_IN_U16 187
|
||||
#define K_SYSCALL_UART_POLL_OUT 188
|
||||
#define K_SYSCALL_UART_POLL_OUT_U16 189
|
||||
#define K_SYSCALL_UART_RX_DISABLE 190
|
||||
#define K_SYSCALL_UART_RX_ENABLE 191
|
||||
#define K_SYSCALL_UART_RX_ENABLE_U16 192
|
||||
#define K_SYSCALL_UART_TX 193
|
||||
#define K_SYSCALL_UART_TX_ABORT 194
|
||||
#define K_SYSCALL_UART_TX_U16 195
|
||||
#define K_SYSCALL_ZEPHYR_FPUTC 196
|
||||
#define K_SYSCALL_ZEPHYR_FWRITE 197
|
||||
#define K_SYSCALL_ZEPHYR_READ_STDIN 198
|
||||
#define K_SYSCALL_ZEPHYR_WRITE_STDOUT 199
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0 200
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1 201
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2 202
|
||||
#define K_SYSCALL_Z_LOG_MSG_STATIC_CREATE 203
|
||||
#define K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK 204
|
||||
#define K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK 205
|
||||
#define K_SYSCALL_BAD 206
|
||||
#define K_SYSCALL_LIMIT 207
|
||||
|
||||
|
||||
/* Following syscalls are not used in image */
|
||||
#define K_SYSCALL_ADC_CHANNEL_SETUP 208
|
||||
#define K_SYSCALL_ADC_GET_DECODER 209
|
||||
#define K_SYSCALL_ADC_READ 210
|
||||
#define K_SYSCALL_ADC_READ_ASYNC 211
|
||||
#define K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET 212
|
||||
#define K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET 213
|
||||
#define K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET 214
|
||||
#define K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET 215
|
||||
#define K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET 216
|
||||
#define K_SYSCALL_AUXDISPLAY_CLEAR 217
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET 218
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET 219
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED 220
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET 221
|
||||
#define K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET 222
|
||||
#define K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND 223
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_OFF 224
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_ON 225
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET 226
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET 227
|
||||
#define K_SYSCALL_AUXDISPLAY_IS_BUSY 228
|
||||
#define K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED 229
|
||||
#define K_SYSCALL_AUXDISPLAY_WRITE 230
|
||||
#define K_SYSCALL_BBRAM_CHECK_INVALID 231
|
||||
#define K_SYSCALL_BBRAM_CHECK_POWER 232
|
||||
#define K_SYSCALL_BBRAM_CHECK_STANDBY_POWER 233
|
||||
#define K_SYSCALL_BBRAM_GET_SIZE 234
|
||||
#define K_SYSCALL_BBRAM_READ 235
|
||||
#define K_SYSCALL_BBRAM_WRITE 236
|
||||
#define K_SYSCALL_BC12_SET_RESULT_CB 237
|
||||
#define K_SYSCALL_BC12_SET_ROLE 238
|
||||
#define K_SYSCALL_CHARGER_CHARGE_ENABLE 239
|
||||
#define K_SYSCALL_CHARGER_GET_PROP 240
|
||||
#define K_SYSCALL_CHARGER_SET_PROP 241
|
||||
#define K_SYSCALL_COMPARATOR_GET_OUTPUT 242
|
||||
#define K_SYSCALL_COMPARATOR_SET_TRIGGER 243
|
||||
#define K_SYSCALL_COMPARATOR_TRIGGER_IS_PENDING 244
|
||||
#define K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM 245
|
||||
#define K_SYSCALL_COUNTER_GET_FREQUENCY 246
|
||||
#define K_SYSCALL_COUNTER_GET_GUARD_PERIOD 247
|
||||
#define K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE 248
|
||||
#define K_SYSCALL_COUNTER_GET_NUM_OF_CHANNELS 249
|
||||
#define K_SYSCALL_COUNTER_GET_PENDING_INT 250
|
||||
#define K_SYSCALL_COUNTER_GET_TOP_VALUE 251
|
||||
#define K_SYSCALL_COUNTER_GET_VALUE 252
|
||||
#define K_SYSCALL_COUNTER_GET_VALUE_64 253
|
||||
#define K_SYSCALL_COUNTER_IS_COUNTING_UP 254
|
||||
#define K_SYSCALL_COUNTER_RESET 255
|
||||
#define K_SYSCALL_COUNTER_SET_CHANNEL_ALARM 256
|
||||
#define K_SYSCALL_COUNTER_SET_GUARD_PERIOD 257
|
||||
#define K_SYSCALL_COUNTER_SET_TOP_VALUE 258
|
||||
#define K_SYSCALL_COUNTER_START 259
|
||||
#define K_SYSCALL_COUNTER_STOP 260
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_NS 261
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_US 262
|
||||
#define K_SYSCALL_COUNTER_US_TO_TICKS 263
|
||||
#define K_SYSCALL_CRC_BEGIN 264
|
||||
#define K_SYSCALL_CRC_FINISH 265
|
||||
#define K_SYSCALL_CRC_UPDATE 266
|
||||
#define K_SYSCALL_DAC_CHANNEL_SETUP 267
|
||||
#define K_SYSCALL_DAC_WRITE_VALUE 268
|
||||
#define K_SYSCALL_DEVMUX_SELECT_GET 269
|
||||
#define K_SYSCALL_DEVMUX_SELECT_SET 270
|
||||
#define K_SYSCALL_EEPROM_GET_SIZE 271
|
||||
#define K_SYSCALL_EEPROM_READ 272
|
||||
#define K_SYSCALL_EEPROM_WRITE 273
|
||||
#define K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF 274
|
||||
#define K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING 275
|
||||
#define K_SYSCALL_ENTROPY_GET_ENTROPY 276
|
||||
#define K_SYSCALL_ESPI_CONFIG 277
|
||||
#define K_SYSCALL_ESPI_FLASH_ERASE 278
|
||||
#define K_SYSCALL_ESPI_GET_CHANNEL_STATUS 279
|
||||
#define K_SYSCALL_ESPI_READ_FLASH 280
|
||||
#define K_SYSCALL_ESPI_READ_LPC_REQUEST 281
|
||||
#define K_SYSCALL_ESPI_READ_REQUEST 282
|
||||
#define K_SYSCALL_ESPI_RECEIVE_OOB 283
|
||||
#define K_SYSCALL_ESPI_RECEIVE_VWIRE 284
|
||||
#define K_SYSCALL_ESPI_SAF_ACTIVATE 285
|
||||
#define K_SYSCALL_ESPI_SAF_CONFIG 286
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_ERASE 287
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_READ 288
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS 289
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_WRITE 290
|
||||
#define K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS 291
|
||||
#define K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS 292
|
||||
#define K_SYSCALL_ESPI_SEND_OOB 293
|
||||
#define K_SYSCALL_ESPI_SEND_VWIRE 294
|
||||
#define K_SYSCALL_ESPI_WRITE_FLASH 295
|
||||
#define K_SYSCALL_ESPI_WRITE_LPC_REQUEST 296
|
||||
#define K_SYSCALL_ESPI_WRITE_REQUEST 297
|
||||
#define K_SYSCALL_FLASH_COPY 298
|
||||
#define K_SYSCALL_FLASH_ERASE 299
|
||||
#define K_SYSCALL_FLASH_EX_OP 300
|
||||
#define K_SYSCALL_FLASH_FILL 301
|
||||
#define K_SYSCALL_FLASH_FLATTEN 302
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_COUNT 303
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX 304
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS 305
|
||||
#define K_SYSCALL_FLASH_GET_PARAMETERS 306
|
||||
#define K_SYSCALL_FLASH_GET_SIZE 307
|
||||
#define K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE 308
|
||||
#define K_SYSCALL_FLASH_READ 309
|
||||
#define K_SYSCALL_FLASH_READ_JEDEC_ID 310
|
||||
#define K_SYSCALL_FLASH_SFDP_READ 311
|
||||
#define K_SYSCALL_FLASH_SIMULATOR_GET_MEMORY 312
|
||||
#define K_SYSCALL_FLASH_WRITE 313
|
||||
#define K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF 314
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP 315
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_PROP 316
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_PROPS 317
|
||||
#define K_SYSCALL_FUEL_GAUGE_SET_PROP 318
|
||||
#define K_SYSCALL_FUEL_GAUGE_SET_PROPS 319
|
||||
#define K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS 320
|
||||
#define K_SYSCALL_GNSS_GET_FIX_RATE 321
|
||||
#define K_SYSCALL_GNSS_GET_LATEST_TIMEPULSE 322
|
||||
#define K_SYSCALL_GNSS_GET_NAVIGATION_MODE 323
|
||||
#define K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS 324
|
||||
#define K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS 325
|
||||
#define K_SYSCALL_GNSS_SET_FIX_RATE 326
|
||||
#define K_SYSCALL_GNSS_SET_NAVIGATION_MODE 327
|
||||
#define K_SYSCALL_HAPTICS_START_OUTPUT 328
|
||||
#define K_SYSCALL_HAPTICS_STOP_OUTPUT 329
|
||||
#define K_SYSCALL_I2C_CONFIGURE 330
|
||||
#define K_SYSCALL_I2C_GET_CONFIG 331
|
||||
#define K_SYSCALL_I2C_RECOVER_BUS 332
|
||||
#define K_SYSCALL_I2C_TARGET_DRIVER_REGISTER 333
|
||||
#define K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER 334
|
||||
#define K_SYSCALL_I2C_TRANSFER 335
|
||||
#define K_SYSCALL_I2S_BUF_READ 336
|
||||
#define K_SYSCALL_I2S_BUF_WRITE 337
|
||||
#define K_SYSCALL_I2S_CONFIGURE 338
|
||||
#define K_SYSCALL_I2S_TRIGGER 339
|
||||
#define K_SYSCALL_I3C_DO_CCC 340
|
||||
#define K_SYSCALL_I3C_TRANSFER 341
|
||||
#define K_SYSCALL_IPM_COMPLETE 342
|
||||
#define K_SYSCALL_IPM_MAX_DATA_SIZE_GET 343
|
||||
#define K_SYSCALL_IPM_MAX_ID_VAL_GET 344
|
||||
#define K_SYSCALL_IPM_SEND 345
|
||||
#define K_SYSCALL_IPM_SET_ENABLED 346
|
||||
#define K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS 347
|
||||
#define K_SYSCALL_IVSHMEM_GET_ID 348
|
||||
#define K_SYSCALL_IVSHMEM_GET_MAX_PEERS 349
|
||||
#define K_SYSCALL_IVSHMEM_GET_MEM 350
|
||||
#define K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION 351
|
||||
#define K_SYSCALL_IVSHMEM_GET_PROTOCOL 352
|
||||
#define K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION 353
|
||||
#define K_SYSCALL_IVSHMEM_GET_STATE 354
|
||||
#define K_SYSCALL_IVSHMEM_GET_VECTORS 355
|
||||
#define K_SYSCALL_IVSHMEM_INT_PEER 356
|
||||
#define K_SYSCALL_IVSHMEM_REGISTER_HANDLER 357
|
||||
#define K_SYSCALL_IVSHMEM_SET_STATE 358
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET 359
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET 360
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET 361
|
||||
#define K_SYSCALL_K_MEM_PAGING_STATS_GET 362
|
||||
#define K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET 363
|
||||
#define K_SYSCALL_LED_BLINK 364
|
||||
#define K_SYSCALL_LED_GET_INFO 365
|
||||
#define K_SYSCALL_LED_OFF 366
|
||||
#define K_SYSCALL_LED_ON 367
|
||||
#define K_SYSCALL_LED_SET_BRIGHTNESS 368
|
||||
#define K_SYSCALL_LED_SET_CHANNEL 369
|
||||
#define K_SYSCALL_LED_SET_COLOR 370
|
||||
#define K_SYSCALL_LED_WRITE_CHANNELS 371
|
||||
#define K_SYSCALL_LLEXT_GET_FN_TABLE 372
|
||||
#define K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT 373
|
||||
#define K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT 374
|
||||
#define K_SYSCALL_MBOX_MAX_CHANNELS_GET 375
|
||||
#define K_SYSCALL_MBOX_MTU_GET 376
|
||||
#define K_SYSCALL_MBOX_SEND 377
|
||||
#define K_SYSCALL_MBOX_SET_ENABLED 378
|
||||
#define K_SYSCALL_MDIO_BUS_DISABLE 379
|
||||
#define K_SYSCALL_MDIO_BUS_ENABLE 380
|
||||
#define K_SYSCALL_MDIO_READ 381
|
||||
#define K_SYSCALL_MDIO_READ_C45 382
|
||||
#define K_SYSCALL_MDIO_WRITE 383
|
||||
#define K_SYSCALL_MDIO_WRITE_C45 384
|
||||
#define K_SYSCALL_MSPI_CONFIG 385
|
||||
#define K_SYSCALL_MSPI_DEV_CONFIG 386
|
||||
#define K_SYSCALL_MSPI_GET_CHANNEL_STATUS 387
|
||||
#define K_SYSCALL_MSPI_SCRAMBLE_CONFIG 388
|
||||
#define K_SYSCALL_MSPI_TIMING_CONFIG 389
|
||||
#define K_SYSCALL_MSPI_TRANSCEIVE 390
|
||||
#define K_SYSCALL_MSPI_XIP_CONFIG 391
|
||||
#define K_SYSCALL_NET_ADDR_NTOP 392
|
||||
#define K_SYSCALL_NET_ADDR_PTON 393
|
||||
#define K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX 394
|
||||
#define K_SYSCALL_NET_IF_GET_BY_INDEX 395
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_ADD_BY_INDEX 396
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_LOOKUP_BY_INDEX 397
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX 398
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_GW_BY_INDEX 399
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_ADDR_BY_INDEX 400
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_INDEX 401
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_ADD_BY_INDEX 402
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_LOOKUP_BY_INDEX 403
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_RM_BY_INDEX 404
|
||||
#define K_SYSCALL_NET_SOCKET_SERVICE_REGISTER 405
|
||||
#define K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE 406
|
||||
#define K_SYSCALL_OPAMP_SET_GAIN 407
|
||||
#define K_SYSCALL_PECI_CONFIG 408
|
||||
#define K_SYSCALL_PECI_DISABLE 409
|
||||
#define K_SYSCALL_PECI_ENABLE 410
|
||||
#define K_SYSCALL_PECI_TRANSFER 411
|
||||
#define K_SYSCALL_PS2_CONFIG 412
|
||||
#define K_SYSCALL_PS2_DISABLE_CALLBACK 413
|
||||
#define K_SYSCALL_PS2_ENABLE_CALLBACK 414
|
||||
#define K_SYSCALL_PS2_READ 415
|
||||
#define K_SYSCALL_PS2_WRITE 416
|
||||
#define K_SYSCALL_PSI5_REGISTER_CALLBACK 417
|
||||
#define K_SYSCALL_PSI5_SEND 418
|
||||
#define K_SYSCALL_PSI5_START_SYNC 419
|
||||
#define K_SYSCALL_PSI5_STOP_SYNC 420
|
||||
#define K_SYSCALL_PTP_CLOCK_GET 421
|
||||
#define K_SYSCALL_PWM_CAPTURE_CYCLES 422
|
||||
#define K_SYSCALL_PWM_DISABLE_CAPTURE 423
|
||||
#define K_SYSCALL_PWM_ENABLE_CAPTURE 424
|
||||
#define K_SYSCALL_PWM_GET_CYCLES_PER_SEC 425
|
||||
#define K_SYSCALL_PWM_SET_CYCLES 426
|
||||
#define K_SYSCALL_RENESAS_ELC_DISABLE 427
|
||||
#define K_SYSCALL_RENESAS_ELC_ENABLE 428
|
||||
#define K_SYSCALL_RENESAS_ELC_LINK_BREAK 429
|
||||
#define K_SYSCALL_RENESAS_ELC_LINK_SET 430
|
||||
#define K_SYSCALL_RENESAS_ELC_SOFTWARE_EVENT_GENERATE 431
|
||||
#define K_SYSCALL_RENESAS_RA_CTSU_GROUP_CONFIGURE 432
|
||||
#define K_SYSCALL_RENESAS_RX_CTSU_GROUP_CONFIGURE 433
|
||||
#define K_SYSCALL_RETAINED_MEM_CLEAR 434
|
||||
#define K_SYSCALL_RETAINED_MEM_READ 435
|
||||
#define K_SYSCALL_RETAINED_MEM_SIZE 436
|
||||
#define K_SYSCALL_RETAINED_MEM_WRITE 437
|
||||
#define K_SYSCALL_RTC_ALARM_GET_SUPPORTED_FIELDS 438
|
||||
#define K_SYSCALL_RTC_ALARM_GET_TIME 439
|
||||
#define K_SYSCALL_RTC_ALARM_IS_PENDING 440
|
||||
#define K_SYSCALL_RTC_ALARM_SET_TIME 441
|
||||
#define K_SYSCALL_RTC_GET_CALIBRATION 442
|
||||
#define K_SYSCALL_RTC_GET_TIME 443
|
||||
#define K_SYSCALL_RTC_SET_CALIBRATION 444
|
||||
#define K_SYSCALL_RTC_SET_TIME 445
|
||||
#define K_SYSCALL_RTIO_CQE_COPY_OUT 446
|
||||
#define K_SYSCALL_RTIO_CQE_GET_MEMPOOL_BUFFER 447
|
||||
#define K_SYSCALL_RTIO_POOL_ACQUIRE 448
|
||||
#define K_SYSCALL_RTIO_POOL_RELEASE 449
|
||||
#define K_SYSCALL_RTIO_RELEASE_BUFFER 450
|
||||
#define K_SYSCALL_RTIO_SQE_CANCEL 451
|
||||
#define K_SYSCALL_RTIO_SQE_COPY_IN_GET_HANDLES 452
|
||||
#define K_SYSCALL_RTIO_SQE_SIGNAL 453
|
||||
#define K_SYSCALL_RTIO_SUBMIT 454
|
||||
#define K_SYSCALL_SDHC_CARD_BUSY 455
|
||||
#define K_SYSCALL_SDHC_CARD_PRESENT 456
|
||||
#define K_SYSCALL_SDHC_DISABLE_INTERRUPT 457
|
||||
#define K_SYSCALL_SDHC_ENABLE_INTERRUPT 458
|
||||
#define K_SYSCALL_SDHC_EXECUTE_TUNING 459
|
||||
#define K_SYSCALL_SDHC_GET_HOST_PROPS 460
|
||||
#define K_SYSCALL_SDHC_HW_RESET 461
|
||||
#define K_SYSCALL_SDHC_REQUEST 462
|
||||
#define K_SYSCALL_SDHC_SET_IO 463
|
||||
#define K_SYSCALL_SENSOR_ATTR_GET 464
|
||||
#define K_SYSCALL_SENSOR_ATTR_SET 465
|
||||
#define K_SYSCALL_SENSOR_CHANNEL_GET 466
|
||||
#define K_SYSCALL_SENSOR_GET_DECODER 467
|
||||
#define K_SYSCALL_SENSOR_RECONFIGURE_READ_IODEV 468
|
||||
#define K_SYSCALL_SENSOR_SAMPLE_FETCH 469
|
||||
#define K_SYSCALL_SENSOR_SAMPLE_FETCH_CHAN 470
|
||||
#define K_SYSCALL_SENT_REGISTER_CALLBACK 471
|
||||
#define K_SYSCALL_SENT_START_LISTENING 472
|
||||
#define K_SYSCALL_SENT_STOP_LISTENING 473
|
||||
#define K_SYSCALL_SIP_SUPERVISORY_CALL 474
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_REQ 475
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_RES 476
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FORMAT_TRANS_ID 477
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FREE_ASYNC_MEMORY 478
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FUNC_ID_VALID 479
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_GET_ERROR_CODE 480
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_GET_TRANS_IDX 481
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_UPDATE_TRANS_ID 482
|
||||
#define K_SYSCALL_SMBUS_BLOCK_PCALL 483
|
||||
#define K_SYSCALL_SMBUS_BLOCK_READ 484
|
||||
#define K_SYSCALL_SMBUS_BLOCK_WRITE 485
|
||||
#define K_SYSCALL_SMBUS_BYTE_DATA_READ 486
|
||||
#define K_SYSCALL_SMBUS_BYTE_DATA_WRITE 487
|
||||
#define K_SYSCALL_SMBUS_BYTE_READ 488
|
||||
#define K_SYSCALL_SMBUS_BYTE_WRITE 489
|
||||
#define K_SYSCALL_SMBUS_CONFIGURE 490
|
||||
#define K_SYSCALL_SMBUS_GET_CONFIG 491
|
||||
#define K_SYSCALL_SMBUS_HOST_NOTIFY_REMOVE_CB 492
|
||||
#define K_SYSCALL_SMBUS_PCALL 493
|
||||
#define K_SYSCALL_SMBUS_QUICK 494
|
||||
#define K_SYSCALL_SMBUS_SMBALERT_REMOVE_CB 495
|
||||
#define K_SYSCALL_SMBUS_WORD_DATA_READ 496
|
||||
#define K_SYSCALL_SMBUS_WORD_DATA_WRITE 497
|
||||
#define K_SYSCALL_SPI_RELEASE 498
|
||||
#define K_SYSCALL_SPI_TRANSCEIVE 499
|
||||
#define K_SYSCALL_STEPPER_DISABLE 500
|
||||
#define K_SYSCALL_STEPPER_ENABLE 501
|
||||
#define K_SYSCALL_STEPPER_GET_ACTUAL_POSITION 502
|
||||
#define K_SYSCALL_STEPPER_GET_MICRO_STEP_RES 503
|
||||
#define K_SYSCALL_STEPPER_IS_MOVING 504
|
||||
#define K_SYSCALL_STEPPER_MOVE_BY 505
|
||||
#define K_SYSCALL_STEPPER_MOVE_TO 506
|
||||
#define K_SYSCALL_STEPPER_RUN 507
|
||||
#define K_SYSCALL_STEPPER_SET_EVENT_CALLBACK 508
|
||||
#define K_SYSCALL_STEPPER_SET_MICROSTEP_INTERVAL 509
|
||||
#define K_SYSCALL_STEPPER_SET_MICRO_STEP_RES 510
|
||||
#define K_SYSCALL_STEPPER_SET_REFERENCE_POSITION 511
|
||||
#define K_SYSCALL_STEPPER_STOP 512
|
||||
#define K_SYSCALL_SYSCON_GET_BASE 513
|
||||
#define K_SYSCALL_SYSCON_GET_SIZE 514
|
||||
#define K_SYSCALL_SYSCON_READ_REG 515
|
||||
#define K_SYSCALL_SYSCON_WRITE_REG 516
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE 517
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE 518
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE 519
|
||||
#define K_SYSCALL_SYS_CSRAND_GET 520
|
||||
#define K_SYSCALL_SYS_RAND_GET 521
|
||||
#define K_SYSCALL_TEE_CANCEL 522
|
||||
#define K_SYSCALL_TEE_CLOSE_SESSION 523
|
||||
#define K_SYSCALL_TEE_GET_VERSION 524
|
||||
#define K_SYSCALL_TEE_INVOKE_FUNC 525
|
||||
#define K_SYSCALL_TEE_OPEN_SESSION 526
|
||||
#define K_SYSCALL_TEE_SHM_ALLOC 527
|
||||
#define K_SYSCALL_TEE_SHM_FREE 528
|
||||
#define K_SYSCALL_TEE_SHM_REGISTER 529
|
||||
#define K_SYSCALL_TEE_SHM_UNREGISTER 530
|
||||
#define K_SYSCALL_TEE_SUPPL_RECV 531
|
||||
#define K_SYSCALL_TEE_SUPPL_SEND 532
|
||||
#define K_SYSCALL_TGPIO_PIN_CONFIG_EXT_TIMESTAMP 533
|
||||
#define K_SYSCALL_TGPIO_PIN_DISABLE 534
|
||||
#define K_SYSCALL_TGPIO_PIN_PERIODIC_OUTPUT 535
|
||||
#define K_SYSCALL_TGPIO_PIN_READ_TS_EC 536
|
||||
#define K_SYSCALL_TGPIO_PORT_GET_CYCLES_PER_SECOND 537
|
||||
#define K_SYSCALL_TGPIO_PORT_GET_TIME 538
|
||||
#define K_SYSCALL_UPDATEHUB_AUTOHANDLER 539
|
||||
#define K_SYSCALL_UPDATEHUB_CONFIRM 540
|
||||
#define K_SYSCALL_UPDATEHUB_PROBE 541
|
||||
#define K_SYSCALL_UPDATEHUB_REBOOT 542
|
||||
#define K_SYSCALL_UPDATEHUB_REPORT_ERROR 543
|
||||
#define K_SYSCALL_UPDATEHUB_UPDATE 544
|
||||
#define K_SYSCALL_USER_FAULT 545
|
||||
#define K_SYSCALL_W1_CHANGE_BUS_LOCK 546
|
||||
#define K_SYSCALL_W1_CONFIGURE 547
|
||||
#define K_SYSCALL_W1_GET_SLAVE_COUNT 548
|
||||
#define K_SYSCALL_W1_READ_BIT 549
|
||||
#define K_SYSCALL_W1_READ_BLOCK 550
|
||||
#define K_SYSCALL_W1_READ_BYTE 551
|
||||
#define K_SYSCALL_W1_RESET_BUS 552
|
||||
#define K_SYSCALL_W1_SEARCH_BUS 553
|
||||
#define K_SYSCALL_W1_WRITE_BIT 554
|
||||
#define K_SYSCALL_W1_WRITE_BLOCK 555
|
||||
#define K_SYSCALL_W1_WRITE_BYTE 556
|
||||
#define K_SYSCALL_WDT_DISABLE 557
|
||||
#define K_SYSCALL_WDT_FEED 558
|
||||
#define K_SYSCALL_WDT_SETUP 559
|
||||
#define K_SYSCALL_XTENSA_USER_FAULT 560
|
||||
#define K_SYSCALL_ZSOCK_ACCEPT 561
|
||||
#define K_SYSCALL_ZSOCK_BIND 562
|
||||
#define K_SYSCALL_ZSOCK_CLOSE 563
|
||||
#define K_SYSCALL_ZSOCK_CONNECT 564
|
||||
#define K_SYSCALL_ZSOCK_FCNTL_IMPL 565
|
||||
#define K_SYSCALL_ZSOCK_GETHOSTNAME 566
|
||||
#define K_SYSCALL_ZSOCK_GETPEERNAME 567
|
||||
#define K_SYSCALL_ZSOCK_GETSOCKNAME 568
|
||||
#define K_SYSCALL_ZSOCK_GETSOCKOPT 569
|
||||
#define K_SYSCALL_ZSOCK_GET_CONTEXT_OBJECT 570
|
||||
#define K_SYSCALL_ZSOCK_INET_PTON 571
|
||||
#define K_SYSCALL_ZSOCK_IOCTL_IMPL 572
|
||||
#define K_SYSCALL_ZSOCK_LISTEN 573
|
||||
#define K_SYSCALL_ZSOCK_RECVFROM 574
|
||||
#define K_SYSCALL_ZSOCK_RECVMSG 575
|
||||
#define K_SYSCALL_ZSOCK_SENDMSG 576
|
||||
#define K_SYSCALL_ZSOCK_SENDTO 577
|
||||
#define K_SYSCALL_ZSOCK_SETSOCKOPT 578
|
||||
#define K_SYSCALL_ZSOCK_SHUTDOWN 579
|
||||
#define K_SYSCALL_ZSOCK_SOCKET 580
|
||||
#define K_SYSCALL_ZSOCK_SOCKETPAIR 581
|
||||
#define K_SYSCALL_ZVFS_POLL 582
|
||||
#define K_SYSCALL_ZVFS_SELECT 583
|
||||
#define K_SYSCALL_Z_ERRNO 584
|
||||
#define K_SYSCALL_Z_ZSOCK_GETADDRINFO_INTERNAL 585
|
||||
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#endif /* _ASMLANGUAGE */
|
||||
|
||||
#endif /* ZEPHYR_SYSCALL_LIST_H */
|
||||
@@ -0,0 +1,431 @@
|
||||
#define CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE 1024
|
||||
#define CONFIG_MAIN_STACK_SIZE 4096
|
||||
#define CONFIG_SERIAL 1
|
||||
#define CONFIG_NUM_IRQS 31
|
||||
#define CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC 64000000
|
||||
#define CONFIG_FLASH_SIZE 512
|
||||
#define CONFIG_FLASH_BASE_ADDRESS 0x8000000
|
||||
#define CONFIG_MP_MAX_NUM_CPUS 1
|
||||
#define CONFIG_CLOCK_CONTROL 1
|
||||
#define CONFIG_IDLE_STACK_SIZE 256
|
||||
#define CONFIG_ISR_STACK_SIZE 2048
|
||||
#define CONFIG_SYS_CLOCK_TICKS_PER_SEC 10000
|
||||
#define CONFIG_BUILD_OUTPUT_BIN 1
|
||||
#define CONFIG_ROM_START_OFFSET 0x0
|
||||
#define CONFIG_KERNEL_ENTRY "__start"
|
||||
#define CONFIG_XIP 1
|
||||
#define CONFIG_HAS_FLASH_LOAD_OFFSET 1
|
||||
#define CONFIG_CPU_HAS_ARM_MPU 1
|
||||
#define CONFIG_TICKLESS_KERNEL 1
|
||||
#define CONFIG_CORTEX_M_SYSTICK 1
|
||||
#define CONFIG_CLOCK_CONTROL_INIT_PRIORITY 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_FLASH_LOAD_OFFSET 0x0
|
||||
#define CONFIG_SYS_CLOCK_EXISTS 1
|
||||
#define CONFIG_GPIO 1
|
||||
#define CONFIG_LOG 1
|
||||
#define CONFIG_DCACHE_LINE_SIZE 32
|
||||
#define CONFIG_RESET 1
|
||||
#define CONFIG_ARCH_SW_ISR_TABLE_ALIGN 4
|
||||
#define CONFIG_LOG_DOMAIN_NAME ""
|
||||
#define CONFIG_LOG_PROCESS_THREAD_STACK_SIZE 768
|
||||
#define CONFIG_UART_USE_RUNTIME_CONFIGURE 1
|
||||
#define CONFIG_SOC_EARLY_INIT_HOOK 1
|
||||
#define CONFIG_CONSOLE 1
|
||||
#define CONFIG_COMMON_LIBC_MALLOC_ARENA_SIZE -1
|
||||
#define CONFIG_ATOMIC_OPERATIONS_C 1
|
||||
#define CONFIG_GEN_SW_ISR_TABLE 1
|
||||
#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_MULTITHREADING 1
|
||||
#define CONFIG_LINKER_USE_RELAX 1
|
||||
#define CONFIG_ICACHE_LINE_SIZE 32
|
||||
#define CONFIG_DT_HAS_ARM_ARMV6M_SYSTICK_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ARM_CORTEX_M0__ENABLED 1
|
||||
#define CONFIG_DT_HAS_ARM_V6M_NVIC_ENABLED 1
|
||||
#define CONFIG_DT_HAS_FIXED_CLOCK_ENABLED 1
|
||||
#define CONFIG_DT_HAS_FIXED_PARTITIONS_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_SOC_NV_FLASH_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_EXTI_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_FDCAN_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_HSI48_CLOCK_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_LPTIM_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_NV_FLASH_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_PINCTRL_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_RCC_RCTL_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_RTC_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_TEMP_CAL_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_USB_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_VBAT_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_VREF_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32_WATCHDOG_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32F0_RCC_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32G0_EXTI_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32G0_FLASH_CONTROLLER_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32G0_HSI_CLOCK_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ST_STM32G0_PLL_CLOCK_ENABLED 1
|
||||
#define CONFIG_DT_HAS_USB_NOP_XCEIV_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ZEPHYR_MEMORY_REGION_ENABLED 1
|
||||
#define CONFIG_DT_HAS_ZEPHYR_POWER_STATE_ENABLED 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_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_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_ZEPHYR_MCUBOOT_MODULE 1
|
||||
#define CONFIG_ZEPHYR_MIPI_SYS_T_MODULE 1
|
||||
#define CONFIG_ZEPHYR_NANOPB_MODULE 1
|
||||
#define CONFIG_ZEPHYR_NRF_WIFI_MODULE 1
|
||||
#define CONFIG_ZEPHYR_OPEN_AMP_MODULE 1
|
||||
#define CONFIG_ZEPHYR_OPENTHREAD_MODULE 1
|
||||
#define CONFIG_ZEPHYR_PERCEPIO_MODULE 1
|
||||
#define CONFIG_ZEPHYR_PICOLIBC_MODULE 1
|
||||
#define CONFIG_ZEPHYR_SEGGER_MODULE 1
|
||||
#define CONFIG_HAS_SEGGER_RTT 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_HAL_PCD 1
|
||||
#define CONFIG_USE_STM32_HAL_PCD_EX 1
|
||||
#define CONFIG_USE_STM32_LL_USB 1
|
||||
#define CONFIG_USE_STM32_LL_UTILS 1
|
||||
#define CONFIG_BOARD "ews"
|
||||
#define CONFIG_BOARD_REVISION ""
|
||||
#define CONFIG_BOARD_TARGET "ews/stm32g0b1xx"
|
||||
#define CONFIG_BOARD_EWS 1
|
||||
#define CONFIG_BOARD_EWS_STM32G0B1XX 1
|
||||
#define CONFIG_BOARD_QUALIFIERS "stm32g0b1xx"
|
||||
#define CONFIG_SOC "stm32g0b1xx"
|
||||
#define CONFIG_SOC_SERIES "stm32g0x"
|
||||
#define CONFIG_SOC_FAMILY "stm32"
|
||||
#define CONFIG_SOC_FAMILY_STM32 1
|
||||
#define CONFIG_SOC_SERIES_STM32G0X 1
|
||||
#define CONFIG_SOC_STM32G0B1XX 1
|
||||
#define CONFIG_HWINFO 1
|
||||
#define CONFIG_SWJ_ANALOG_PRIORITY 49
|
||||
#define CONFIG_HAS_STM32_FLASH_PREFETCH 1
|
||||
#define CONFIG_GPIO_INIT_PRIORITY 40
|
||||
#define CONFIG_SOC_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_SOC_LOG_LEVEL 3
|
||||
#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 4
|
||||
#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_FP16 1
|
||||
#define CONFIG_FP16_IEEE 1
|
||||
#define CONFIG_CPU_CORTEX_M0PLUS 1
|
||||
#define CONFIG_CPU_CORTEX_M_HAS_SYSTICK 1
|
||||
#define CONFIG_CPU_CORTEX_M_HAS_VTOR 1
|
||||
#define CONFIG_ARMV6_M_ARMV8_M_BASELINE 1
|
||||
#define CONFIG_NULL_POINTER_EXCEPTION_DETECTION_NONE 1
|
||||
#define CONFIG_ARM 1
|
||||
#define CONFIG_ARCH_IS_SET 1
|
||||
#define CONFIG_ARCH_SUPPORTS_ROM_OFFSET 1
|
||||
#define CONFIG_ARCH_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_ARCH_LOG_LEVEL 3
|
||||
#define CONFIG_LITTLE_ENDIAN 1
|
||||
#define CONFIG_SRAM_SIZE 144
|
||||
#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_EXCEPTION_DEBUG 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_MPU 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 3
|
||||
#define CONFIG_NUM_COOP_PRIORITIES 16
|
||||
#define CONFIG_MAIN_THREAD_PRIORITY 0
|
||||
#define CONFIG_COOP_ENABLED 1
|
||||
#define CONFIG_PREEMPT_ENABLED 1
|
||||
#define CONFIG_PRIORITY_CEILING -127
|
||||
#define CONFIG_SCHED_SIMPLE 1
|
||||
#define CONFIG_WAITQ_SIMPLE 1
|
||||
#define CONFIG_LIBC_ERRNO 1
|
||||
#define CONFIG_ERRNO 1
|
||||
#define CONFIG_CURRENT_THREAD_USE_TLS 1
|
||||
#define CONFIG_BOOT_BANNER 1
|
||||
#define CONFIG_BOOT_BANNER_STRING "Booting Zephyr OS build"
|
||||
#define CONFIG_BOOT_DELAY 0
|
||||
#define CONFIG_SYSTEM_WORKQUEUE_PRIORITY -1
|
||||
#define CONFIG_SYSTEM_WORKQUEUE_WORK_TIMEOUT_MS 0
|
||||
#define CONFIG_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 8192
|
||||
#define CONFIG_SWAP_NONATOMIC 1
|
||||
#define CONFIG_TIMEOUT_64BIT 1
|
||||
#define CONFIG_SYS_CLOCK_MAX_TIMEOUT_DAYS 365
|
||||
#define CONFIG_TOOLCHAIN_SUPPORTS_THREAD_LOCAL_STORAGE 1
|
||||
#define CONFIG_THREAD_LOCAL_STORAGE 1
|
||||
#define CONFIG_TOOLCHAIN_SUPPORTS_STATIC_INIT_GNU 1
|
||||
#define CONFIG_DEVICE_DEINIT_SUPPORT 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_CAN 1
|
||||
#define CONFIG_CAN_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_CAN_LOG_LEVEL 3
|
||||
#define CONFIG_CAN_INIT_PRIORITY 80
|
||||
#define CONFIG_CAN_DEFAULT_BITRATE 125000
|
||||
#define CONFIG_CAN_DEFAULT_BITRATE_DATA 1000000
|
||||
#define CONFIG_CAN_SAMPLE_POINT_MARGIN 50
|
||||
#define CONFIG_CAN_FD_MODE 1
|
||||
#define CONFIG_CAN_MAX_STD_ID_FILTER 28
|
||||
#define CONFIG_CAN_MAX_EXT_ID_FILTER 8
|
||||
#define CONFIG_CAN_STM32_FDCAN 1
|
||||
#define CONFIG_CAN_MCAN 1
|
||||
#define CONFIG_CAN_TRANSCEIVER_INIT_PRIORITY 45
|
||||
#define CONFIG_CLOCK_CONTROL_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_CLOCK_CONTROL_LOG_LEVEL 3
|
||||
#define CONFIG_CLOCK_CONTROL_STM32_CUBE 1
|
||||
#define CONFIG_CONSOLE_INPUT_MAX_LINE_LEN 128
|
||||
#define CONFIG_CONSOLE_HAS_DRIVER 1
|
||||
#define CONFIG_CONSOLE_INIT_PRIORITY 60
|
||||
#define CONFIG_UART_CONSOLE 1
|
||||
#define CONFIG_UART_CONSOLE_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_UART_CONSOLE_LOG_LEVEL 3
|
||||
#define CONFIG_GPIO_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_GPIO_LOG_LEVEL 3
|
||||
#define CONFIG_GPIO_STM32 1
|
||||
#define CONFIG_HWINFO_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_HWINFO_LOG_LEVEL 3
|
||||
#define CONFIG_HWINFO_HAS_DRIVER 1
|
||||
#define CONFIG_HWINFO_STM32 1
|
||||
#define CONFIG_INTC_INIT_PRIORITY 40
|
||||
#define CONFIG_INTC_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_INTC_LOG_LEVEL 3
|
||||
#define CONFIG_EXTI_STM32 1
|
||||
#define CONFIG_GPIO_INTC_STM32 1
|
||||
#define CONFIG_PINCTRL 1
|
||||
#define CONFIG_PINCTRL_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_PINCTRL_LOG_LEVEL 3
|
||||
#define CONFIG_PINCTRL_KEEP_SLEEP_STATE 1
|
||||
#define CONFIG_PINCTRL_STM32 1
|
||||
#define CONFIG_PINCTRL_STM32_REMAP_INIT_PRIORITY 2
|
||||
#define CONFIG_RESET_INIT_PRIORITY 35
|
||||
#define CONFIG_RESET_STM32 1
|
||||
#define CONFIG_SERIAL_HAS_DRIVER 1
|
||||
#define CONFIG_SERIAL_SUPPORT_INTERRUPT 1
|
||||
#define CONFIG_SERIAL_INIT_PRIORITY 50
|
||||
#define CONFIG_UART_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_UART_LOG_LEVEL 3
|
||||
#define CONFIG_UART_LINE_CTRL 1
|
||||
#define CONFIG_UART_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_CORTEX_M_SYSTICK_LPM_TIMER_NONE 1
|
||||
#define CONFIG_USB_DEVICE_DRIVER 1
|
||||
#define CONFIG_USB_DEVICE_REMOTE_WAKEUP 1
|
||||
#define CONFIG_USB_DC_STM32 1
|
||||
#define CONFIG_USB_DC_STM32_CLOCK_CHECK 1
|
||||
#define CONFIG_USB_DRIVER_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_USB_DRIVER_LOG_LEVEL 3
|
||||
#define CONFIG_FULL_LIBC_SUPPORTED 1
|
||||
#define CONFIG_MINIMAL_LIBC_SUPPORTED 1
|
||||
#define CONFIG_NEWLIB_LIBC_SUPPORTED 1
|
||||
#define CONFIG_PICOLIBC_SUPPORTED 1
|
||||
#define CONFIG_PICOLIBC 1
|
||||
#define CONFIG_HAS_NEWLIB_LIBC_NANO 1
|
||||
#define CONFIG_COMMON_LIBC_ABORT 1
|
||||
#define CONFIG_COMMON_LIBC_TIME 1
|
||||
#define CONFIG_COMMON_LIBC_MALLOC 1
|
||||
#define CONFIG_COMMON_LIBC_CALLOC 1
|
||||
#define CONFIG_COMMON_LIBC_REALLOCARRAY 1
|
||||
#define CONFIG_PICOLIBC_USE_TOOLCHAIN 1
|
||||
#define CONFIG_PICOLIBC_IO_LONG_LONG 1
|
||||
#define CONFIG_STDOUT_CONSOLE 1
|
||||
#define CONFIG_NEED_LIBC_MEM_PARTITION 1
|
||||
#define CONFIG_SYS_HEAP_ALLOC_LOOPS 3
|
||||
#define CONFIG_SYS_HEAP_ARRAY_SIZE 0
|
||||
#define CONFIG_SYS_HEAP_SMALL_ONLY 1
|
||||
#define CONFIG_ZVFS_OPEN_MAX 0
|
||||
#define CONFIG_MPSC_PBUF 1
|
||||
#define CONFIG_HAS_POWEROFF 1
|
||||
#define CONFIG_CBPRINTF_COMPLETE 1
|
||||
#define CONFIG_CBPRINTF_FULL_INTEGRAL 1
|
||||
#define CONFIG_CBPRINTF_PACKAGE_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_CBPRINTF_PACKAGE_LOG_LEVEL 3
|
||||
#define CONFIG_CBPRINTF_CONVERT_CHECK_PTR 1
|
||||
#define CONFIG_CPU_LOAD_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_CPU_LOAD_LOG_LEVEL 3
|
||||
#define CONFIG_POSIX_AEP_CHOICE_ZEPHYR 1
|
||||
#define CONFIG_TC_PROVIDES_POSIX_C_LANG_SUPPORT_R 1
|
||||
#define CONFIG_POSIX_C_LANG_SUPPORT_R 1
|
||||
#define CONFIG_POSIX_C_LIB_EXT 1
|
||||
#define CONFIG_LIBGCC_RTLIB 1
|
||||
#define CONFIG_RING_BUFFER 1
|
||||
#define CONFIG_PRINTK 1
|
||||
#define CONFIG_EARLY_CONSOLE 1
|
||||
#define CONFIG_ASSERT_VERBOSE 1
|
||||
#define CONFIG_CPU_LOAD_LOG_PERIODICALLY 0
|
||||
#define CONFIG_LOG_CORE_INIT_PRIORITY 0
|
||||
#define CONFIG_LOG_MODE_DEFERRED 1
|
||||
#define CONFIG_LOG_FLUSH_SLEEP_US 10000
|
||||
#define CONFIG_LOG_DEFAULT_LEVEL 3
|
||||
#define CONFIG_LOG_OVERRIDE_LEVEL 0
|
||||
#define CONFIG_LOG_MAX_LEVEL 4
|
||||
#define CONFIG_LOG_PRINTK 1
|
||||
#define CONFIG_LOG_MODE_OVERFLOW 1
|
||||
#define CONFIG_LOG_PROCESS_TRIGGER_THRESHOLD 10
|
||||
#define CONFIG_LOG_PROCESS_THREAD 1
|
||||
#define CONFIG_LOG_PROCESS_THREAD_STARTUP_DELAY_MS 0
|
||||
#define CONFIG_LOG_PROCESS_THREAD_SLEEP_MS 1000
|
||||
#define CONFIG_LOG_BUFFER_SIZE 1024
|
||||
#define CONFIG_LOG_TRACE_SHORT_TIMESTAMP 1
|
||||
#define CONFIG_LOG_FUNC_NAME_PREFIX_DBG 1
|
||||
#define CONFIG_LOG_BACKEND_SHOW_TIMESTAMP 1
|
||||
#define CONFIG_LOG_BACKEND_SHOW_LEVEL 1
|
||||
#define CONFIG_LOG_BACKEND_SHOW_COLOR 1
|
||||
#define CONFIG_LOG_TAG_MAX_LEN 0
|
||||
#define CONFIG_LOG_BACKEND_SUPPORTS_FORMAT_TIMESTAMP 1
|
||||
#define CONFIG_LOG_BACKEND_FORMAT_TIMESTAMP 1
|
||||
#define CONFIG_LOG_OUTPUT_FORMAT_TIME_TIMESTAMP 1
|
||||
#define CONFIG_LOG_BACKEND_UART 1
|
||||
#define CONFIG_LOG_BACKEND_UART_BUFFER_SIZE 1
|
||||
#define CONFIG_LOG_BACKEND_UART_AUTOSTART 1
|
||||
#define CONFIG_LOG_BACKEND_UART_OUTPUT_TEXT 1
|
||||
#define CONFIG_LOG_BACKEND_UART_OUTPUT_DEFAULT 0
|
||||
#define CONFIG_LOG_USE_VLA 1
|
||||
#define CONFIG_LOG_SIMPLE_MSG_OPTIMIZE 1
|
||||
#define CONFIG_LOG_FAILURE_REPORT_PERIOD 1000
|
||||
#define CONFIG_LOG_RATELIMIT 1
|
||||
#define CONFIG_LOG_RATELIMIT_INTERVAL_MS 5000
|
||||
#define CONFIG_LOG_OUTPUT 1
|
||||
#define CONFIG_HAS_PM 1
|
||||
#define CONFIG_TIMER_RANDOM_INITIAL_STATE 123456789
|
||||
#define CONFIG_COVERAGE_DUMP_PATH_EXCLUDE ""
|
||||
#define CONFIG_USB_DEVICE_STACK 1
|
||||
#define CONFIG_USB_DEVICE_LOG_LEVEL_DEFAULT 1
|
||||
#define CONFIG_USB_DEVICE_LOG_LEVEL 3
|
||||
#define CONFIG_USB_DEVICE_VID 0x1d50
|
||||
#define CONFIG_USB_DEVICE_PID 0x606f
|
||||
#define CONFIG_USB_DEVICE_MANUFACTURER "EWS"
|
||||
#define CONFIG_USB_DEVICE_PRODUCT "EWS gs_usb CAN-FD"
|
||||
#define CONFIG_USB_DEVICE_SN "0123456789ABCDEF"
|
||||
#define CONFIG_USB_MAX_NUM_TRANSFERS 4
|
||||
#define CONFIG_USB_REQUEST_BUFFER_SIZE 128
|
||||
#define CONFIG_USB_MAX_ALT_SETTING 8
|
||||
#define CONFIG_USB_NUMOF_EP_WRITE_RETRIES 3
|
||||
#define CONFIG_USB_SELF_POWERED 1
|
||||
#define CONFIG_USB_MAX_POWER 50
|
||||
#define CONFIG_TOOLCHAIN_ZEPHYR_0_17 1
|
||||
#define CONFIG_TOOLCHAIN_ZEPHYR_SUPPORTS_THREAD_LOCAL_STORAGE 1
|
||||
#define CONFIG_TOOLCHAIN_ZEPHYR_SUPPORTS_GNU_EXTENSIONS 1
|
||||
#define CONFIG_LINKER_ORPHAN_SECTION_WARN 1
|
||||
#define CONFIG_FLASH_LOAD_SIZE 0x0
|
||||
#define CONFIG_ROM_END_OFFSET 0x0
|
||||
#define CONFIG_LD_LINKER_SCRIPT_SUPPORTED 1
|
||||
#define CONFIG_LD_LINKER_TEMPLATE 1
|
||||
#define CONFIG_LINKER_SORT_BY_ALIGNMENT 1
|
||||
#define CONFIG_LINKER_GENERIC_SECTIONS_PRESENT_AT_BOOT 1
|
||||
#define CONFIG_LINKER_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_C99 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_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_DEPRECATED 1
|
||||
#define CONFIG_WARN_DEPRECATED 1
|
||||
#define CONFIG_ENFORCE_ZEPHYR_STDINT 1
|
||||
#define CONFIG_LEGACY_GENERATED_INCLUDE_PATH 1
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1,180 @@
|
||||
#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_CAN(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, can, CAN)
|
||||
|
||||
#define K_SYSCALL_DRIVER_GPIO(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, gpio, GPIO)
|
||||
|
||||
#define K_SYSCALL_DRIVER_RESET(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, reset, RESET)
|
||||
|
||||
#define K_SYSCALL_DRIVER_SHARED_IRQ(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, shared_irq, SHARED_IRQ)
|
||||
|
||||
#define K_SYSCALL_DRIVER_CRYPTO(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, crypto, CRYPTO)
|
||||
|
||||
#define K_SYSCALL_DRIVER_ADC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, adc, ADC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_AUXDISPLAY(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, auxdisplay, AUXDISPLAY)
|
||||
|
||||
#define K_SYSCALL_DRIVER_BBRAM(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, bbram, BBRAM)
|
||||
|
||||
#define K_SYSCALL_DRIVER_BT_HCI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, bt_hci, BT_HCI)
|
||||
|
||||
#define K_SYSCALL_DRIVER_CELLULAR(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, cellular, CELLULAR)
|
||||
|
||||
#define K_SYSCALL_DRIVER_CHARGER(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, charger, CHARGER)
|
||||
|
||||
#define K_SYSCALL_DRIVER_CLOCK_CONTROL(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, clock_control, CLOCK_CONTROL)
|
||||
|
||||
#define K_SYSCALL_DRIVER_COMPARATOR(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, comparator, COMPARATOR)
|
||||
|
||||
#define K_SYSCALL_DRIVER_COREDUMP(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, coredump, COREDUMP)
|
||||
|
||||
#define K_SYSCALL_DRIVER_COUNTER(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, counter, COUNTER)
|
||||
|
||||
#define K_SYSCALL_DRIVER_CRC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, crc, CRC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_DAC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, dac, DAC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_DAI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, dai, DAI)
|
||||
|
||||
#define K_SYSCALL_DRIVER_DISPLAY(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, display, DISPLAY)
|
||||
|
||||
#define K_SYSCALL_DRIVER_DMA(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, dma, DMA)
|
||||
|
||||
#define K_SYSCALL_DRIVER_EDAC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, edac, EDAC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_EEPROM(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, eeprom, EEPROM)
|
||||
|
||||
#define K_SYSCALL_DRIVER_EMUL_BBRAM(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, emul_bbram, EMUL_BBRAM)
|
||||
|
||||
#define K_SYSCALL_DRIVER_FUEL_GAUGE_EMUL(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, fuel_gauge_emul, FUEL_GAUGE_EMUL)
|
||||
|
||||
#define K_SYSCALL_DRIVER_EMUL_SENSOR(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, emul_sensor, EMUL_SENSOR)
|
||||
|
||||
#define K_SYSCALL_DRIVER_ENTROPY(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, entropy, ENTROPY)
|
||||
|
||||
#define K_SYSCALL_DRIVER_ESPI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, espi, ESPI)
|
||||
|
||||
#define K_SYSCALL_DRIVER_ESPI_SAF(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, espi_saf, ESPI_SAF)
|
||||
|
||||
#define K_SYSCALL_DRIVER_FLASH(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, flash, FLASH)
|
||||
|
||||
#define K_SYSCALL_DRIVER_FPGA(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, fpga, FPGA)
|
||||
|
||||
#define K_SYSCALL_DRIVER_FUEL_GAUGE(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, fuel_gauge, FUEL_GAUGE)
|
||||
|
||||
#define K_SYSCALL_DRIVER_GNSS(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, gnss, GNSS)
|
||||
|
||||
#define K_SYSCALL_DRIVER_HAPTICS(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, haptics, HAPTICS)
|
||||
|
||||
#define K_SYSCALL_DRIVER_HWSPINLOCK(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, hwspinlock, HWSPINLOCK)
|
||||
|
||||
#define K_SYSCALL_DRIVER_I2C(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, i2c, I2C)
|
||||
|
||||
#define K_SYSCALL_DRIVER_I2C_TARGET(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, i2c_target, I2C_TARGET)
|
||||
|
||||
#define K_SYSCALL_DRIVER_I2S(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, i2s, I2S)
|
||||
|
||||
#define K_SYSCALL_DRIVER_I3C(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, i3c, I3C)
|
||||
|
||||
#define K_SYSCALL_DRIVER_IPM(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, ipm, IPM)
|
||||
|
||||
#define K_SYSCALL_DRIVER_LED(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, led, LED)
|
||||
|
||||
#define K_SYSCALL_DRIVER_LED_STRIP(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, led_strip, LED_STRIP)
|
||||
|
||||
#define K_SYSCALL_DRIVER_LORA(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, lora, LORA)
|
||||
|
||||
#define K_SYSCALL_DRIVER_MBOX(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, mbox, MBOX)
|
||||
|
||||
#define K_SYSCALL_DRIVER_MDIO(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, mdio, MDIO)
|
||||
|
||||
#define K_SYSCALL_DRIVER_MIPI_DBI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, mipi_dbi, MIPI_DBI)
|
||||
|
||||
#define K_SYSCALL_DRIVER_MIPI_DSI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, mipi_dsi, MIPI_DSI)
|
||||
|
||||
#define K_SYSCALL_DRIVER_MSPI(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, mspi, MSPI)
|
||||
|
||||
#define K_SYSCALL_DRIVER_OPAMP(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, opamp, OPAMP)
|
||||
|
||||
#define K_SYSCALL_DRIVER_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_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_STEPPER(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, stepper, STEPPER)
|
||||
|
||||
#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_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_CAN_TRANSCEIVER(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, can_transceiver, CAN_TRANSCEIVER)
|
||||
|
||||
#define K_SYSCALL_DRIVER_NRF_CLOCK_CONTROL(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, nrf_clock_control, NRF_CLOCK_CONTROL)
|
||||
|
||||
#define K_SYSCALL_DRIVER_I3C_TARGET(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, i3c_target, I3C_TARGET)
|
||||
|
||||
#define K_SYSCALL_DRIVER_ITS(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, its, ITS)
|
||||
|
||||
#define K_SYSCALL_DRIVER_VTD(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, vtd, VTD)
|
||||
|
||||
#define K_SYSCALL_DRIVER_RENESAS_ELC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, renesas_elc, RENESAS_ELC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_TGPIO(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, tgpio, TGPIO)
|
||||
|
||||
#define K_SYSCALL_DRIVER_PCIE_CTRL(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, pcie_ctrl, PCIE_CTRL)
|
||||
|
||||
#define K_SYSCALL_DRIVER_PCIE_EP(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, pcie_ep, PCIE_EP)
|
||||
|
||||
#define K_SYSCALL_DRIVER_PSI5(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, psi5, PSI5)
|
||||
|
||||
#define K_SYSCALL_DRIVER_SENT(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, sent, SENT)
|
||||
|
||||
#define K_SYSCALL_DRIVER_SVC(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, svc, SVC)
|
||||
|
||||
#define K_SYSCALL_DRIVER_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 */
|
||||
@@ -0,0 +1,135 @@
|
||||
/* 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_CAN,
|
||||
K_OBJ_DRIVER_GPIO,
|
||||
K_OBJ_DRIVER_RESET,
|
||||
K_OBJ_DRIVER_SHARED_IRQ,
|
||||
K_OBJ_DRIVER_CRYPTO,
|
||||
K_OBJ_DRIVER_ADC,
|
||||
K_OBJ_DRIVER_AUXDISPLAY,
|
||||
K_OBJ_DRIVER_BBRAM,
|
||||
K_OBJ_DRIVER_BT_HCI,
|
||||
K_OBJ_DRIVER_CELLULAR,
|
||||
K_OBJ_DRIVER_CHARGER,
|
||||
K_OBJ_DRIVER_CLOCK_CONTROL,
|
||||
K_OBJ_DRIVER_COMPARATOR,
|
||||
K_OBJ_DRIVER_COREDUMP,
|
||||
K_OBJ_DRIVER_COUNTER,
|
||||
K_OBJ_DRIVER_CRC,
|
||||
K_OBJ_DRIVER_DAC,
|
||||
K_OBJ_DRIVER_DAI,
|
||||
K_OBJ_DRIVER_DISPLAY,
|
||||
K_OBJ_DRIVER_DMA,
|
||||
K_OBJ_DRIVER_EDAC,
|
||||
K_OBJ_DRIVER_EEPROM,
|
||||
K_OBJ_DRIVER_EMUL_BBRAM,
|
||||
K_OBJ_DRIVER_FUEL_GAUGE_EMUL,
|
||||
K_OBJ_DRIVER_EMUL_SENSOR,
|
||||
K_OBJ_DRIVER_ENTROPY,
|
||||
K_OBJ_DRIVER_ESPI,
|
||||
K_OBJ_DRIVER_ESPI_SAF,
|
||||
K_OBJ_DRIVER_FLASH,
|
||||
K_OBJ_DRIVER_FPGA,
|
||||
K_OBJ_DRIVER_FUEL_GAUGE,
|
||||
K_OBJ_DRIVER_GNSS,
|
||||
K_OBJ_DRIVER_HAPTICS,
|
||||
K_OBJ_DRIVER_HWSPINLOCK,
|
||||
K_OBJ_DRIVER_I2C,
|
||||
K_OBJ_DRIVER_I2C_TARGET,
|
||||
K_OBJ_DRIVER_I2S,
|
||||
K_OBJ_DRIVER_I3C,
|
||||
K_OBJ_DRIVER_IPM,
|
||||
K_OBJ_DRIVER_LED,
|
||||
K_OBJ_DRIVER_LED_STRIP,
|
||||
K_OBJ_DRIVER_LORA,
|
||||
K_OBJ_DRIVER_MBOX,
|
||||
K_OBJ_DRIVER_MDIO,
|
||||
K_OBJ_DRIVER_MIPI_DBI,
|
||||
K_OBJ_DRIVER_MIPI_DSI,
|
||||
K_OBJ_DRIVER_MSPI,
|
||||
K_OBJ_DRIVER_OPAMP,
|
||||
K_OBJ_DRIVER_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_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_STEPPER,
|
||||
K_OBJ_DRIVER_SYSCON,
|
||||
K_OBJ_DRIVER_TEE,
|
||||
K_OBJ_DRIVER_VIDEO,
|
||||
K_OBJ_DRIVER_VIRTIO,
|
||||
K_OBJ_DRIVER_W1,
|
||||
K_OBJ_DRIVER_WDT,
|
||||
K_OBJ_DRIVER_CAN_TRANSCEIVER,
|
||||
K_OBJ_DRIVER_NRF_CLOCK_CONTROL,
|
||||
K_OBJ_DRIVER_I3C_TARGET,
|
||||
K_OBJ_DRIVER_ITS,
|
||||
K_OBJ_DRIVER_VTD,
|
||||
K_OBJ_DRIVER_RENESAS_ELC,
|
||||
K_OBJ_DRIVER_TGPIO,
|
||||
K_OBJ_DRIVER_PCIE_CTRL,
|
||||
K_OBJ_DRIVER_PCIE_EP,
|
||||
K_OBJ_DRIVER_PSI5,
|
||||
K_OBJ_DRIVER_SENT,
|
||||
K_OBJ_DRIVER_SVC,
|
||||
K_OBJ_DRIVER_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,
|
||||
@@ -0,0 +1,33 @@
|
||||
/* 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 0x68
|
||||
#define ___thread_t_tls_OFFSET 0x64
|
||||
#define __z_interrupt_stack_SIZEOF 0x800
|
||||
#define __z_interrupt_all_stacks_SIZEOF 0x800
|
||||
#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
|
||||
|
||||
#endif /* __GEN_OFFSETS_H__ */
|
||||
@@ -0,0 +1,15 @@
|
||||
/* Non device/stack objects */
|
||||
case K_OBJ_MEM_SLAB: ret = sizeof(struct k_mem_slab); break;
|
||||
case K_OBJ_MSGQ: ret = sizeof(struct k_msgq); break;
|
||||
case K_OBJ_MUTEX: ret = sizeof(struct k_mutex); break;
|
||||
case K_OBJ_PIPE: ret = sizeof(struct k_pipe); break;
|
||||
case K_OBJ_QUEUE: ret = sizeof(struct k_queue); break;
|
||||
case K_OBJ_POLL_SIGNAL: ret = sizeof(struct k_poll_signal); break;
|
||||
case K_OBJ_SEM: ret = sizeof(struct k_sem); break;
|
||||
case K_OBJ_STACK: ret = sizeof(struct k_stack); break;
|
||||
case K_OBJ_THREAD: ret = sizeof(struct k_thread); break;
|
||||
case K_OBJ_TIMER: ret = sizeof(struct k_timer); break;
|
||||
case K_OBJ_CONDVAR: ret = sizeof(struct k_condvar); break;
|
||||
#ifdef CONFIG_EVENTS
|
||||
case K_OBJ_EVENT: ret = sizeof(struct k_event); break;
|
||||
#endif
|
||||
@@ -0,0 +1,135 @@
|
||||
/* 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_CAN: ret = "can driver"; break;
|
||||
case K_OBJ_DRIVER_GPIO: ret = "gpio driver"; break;
|
||||
case K_OBJ_DRIVER_RESET: ret = "reset driver"; break;
|
||||
case K_OBJ_DRIVER_SHARED_IRQ: ret = "shared_irq driver"; break;
|
||||
case K_OBJ_DRIVER_CRYPTO: ret = "crypto driver"; break;
|
||||
case K_OBJ_DRIVER_ADC: ret = "adc driver"; break;
|
||||
case K_OBJ_DRIVER_AUXDISPLAY: ret = "auxdisplay driver"; break;
|
||||
case K_OBJ_DRIVER_BBRAM: ret = "bbram driver"; break;
|
||||
case K_OBJ_DRIVER_BT_HCI: ret = "bt_hci driver"; break;
|
||||
case K_OBJ_DRIVER_CELLULAR: ret = "cellular driver"; break;
|
||||
case K_OBJ_DRIVER_CHARGER: ret = "charger driver"; break;
|
||||
case K_OBJ_DRIVER_CLOCK_CONTROL: ret = "clock_control driver"; break;
|
||||
case K_OBJ_DRIVER_COMPARATOR: ret = "comparator driver"; break;
|
||||
case K_OBJ_DRIVER_COREDUMP: ret = "coredump driver"; break;
|
||||
case K_OBJ_DRIVER_COUNTER: ret = "counter driver"; break;
|
||||
case K_OBJ_DRIVER_CRC: ret = "crc driver"; break;
|
||||
case K_OBJ_DRIVER_DAC: ret = "dac driver"; break;
|
||||
case K_OBJ_DRIVER_DAI: ret = "dai driver"; break;
|
||||
case K_OBJ_DRIVER_DISPLAY: ret = "display driver"; break;
|
||||
case K_OBJ_DRIVER_DMA: ret = "dma driver"; break;
|
||||
case K_OBJ_DRIVER_EDAC: ret = "edac driver"; break;
|
||||
case K_OBJ_DRIVER_EEPROM: ret = "eeprom driver"; break;
|
||||
case K_OBJ_DRIVER_EMUL_BBRAM: ret = "emul_bbram driver"; break;
|
||||
case K_OBJ_DRIVER_FUEL_GAUGE_EMUL: ret = "fuel_gauge_emul driver"; break;
|
||||
case K_OBJ_DRIVER_EMUL_SENSOR: ret = "emul_sensor driver"; break;
|
||||
case K_OBJ_DRIVER_ENTROPY: ret = "entropy driver"; break;
|
||||
case K_OBJ_DRIVER_ESPI: ret = "espi driver"; break;
|
||||
case K_OBJ_DRIVER_ESPI_SAF: ret = "espi_saf driver"; break;
|
||||
case K_OBJ_DRIVER_FLASH: ret = "flash driver"; break;
|
||||
case K_OBJ_DRIVER_FPGA: ret = "fpga driver"; break;
|
||||
case K_OBJ_DRIVER_FUEL_GAUGE: ret = "fuel_gauge driver"; break;
|
||||
case K_OBJ_DRIVER_GNSS: ret = "gnss driver"; break;
|
||||
case K_OBJ_DRIVER_HAPTICS: ret = "haptics driver"; break;
|
||||
case K_OBJ_DRIVER_HWSPINLOCK: ret = "hwspinlock driver"; break;
|
||||
case K_OBJ_DRIVER_I2C: ret = "i2c driver"; break;
|
||||
case K_OBJ_DRIVER_I2C_TARGET: ret = "i2c_target driver"; break;
|
||||
case K_OBJ_DRIVER_I2S: ret = "i2s driver"; break;
|
||||
case K_OBJ_DRIVER_I3C: ret = "i3c driver"; break;
|
||||
case K_OBJ_DRIVER_IPM: ret = "ipm driver"; break;
|
||||
case K_OBJ_DRIVER_LED: ret = "led driver"; break;
|
||||
case K_OBJ_DRIVER_LED_STRIP: ret = "led_strip driver"; break;
|
||||
case K_OBJ_DRIVER_LORA: ret = "lora driver"; break;
|
||||
case K_OBJ_DRIVER_MBOX: ret = "mbox driver"; break;
|
||||
case K_OBJ_DRIVER_MDIO: ret = "mdio driver"; break;
|
||||
case K_OBJ_DRIVER_MIPI_DBI: ret = "mipi_dbi driver"; break;
|
||||
case K_OBJ_DRIVER_MIPI_DSI: ret = "mipi_dsi driver"; break;
|
||||
case K_OBJ_DRIVER_MSPI: ret = "mspi driver"; break;
|
||||
case K_OBJ_DRIVER_OPAMP: ret = "opamp driver"; break;
|
||||
case K_OBJ_DRIVER_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_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_STEPPER: ret = "stepper driver"; break;
|
||||
case K_OBJ_DRIVER_SYSCON: ret = "syscon driver"; break;
|
||||
case K_OBJ_DRIVER_TEE: ret = "tee 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_CAN_TRANSCEIVER: ret = "can_transceiver driver"; break;
|
||||
case K_OBJ_DRIVER_NRF_CLOCK_CONTROL: ret = "nrf_clock_control driver"; break;
|
||||
case K_OBJ_DRIVER_I3C_TARGET: ret = "i3c_target driver"; break;
|
||||
case K_OBJ_DRIVER_ITS: ret = "its driver"; break;
|
||||
case K_OBJ_DRIVER_VTD: ret = "vtd driver"; break;
|
||||
case K_OBJ_DRIVER_RENESAS_ELC: ret = "renesas_elc driver"; break;
|
||||
case K_OBJ_DRIVER_TGPIO: ret = "tgpio driver"; break;
|
||||
case K_OBJ_DRIVER_PCIE_CTRL: ret = "pcie_ctrl driver"; break;
|
||||
case K_OBJ_DRIVER_PCIE_EP: ret = "pcie_ep driver"; break;
|
||||
case K_OBJ_DRIVER_PSI5: ret = "psi5 driver"; break;
|
||||
case K_OBJ_DRIVER_SENT: ret = "sent driver"; break;
|
||||
case K_OBJ_DRIVER_SVC: ret = "svc driver"; break;
|
||||
case K_OBJ_DRIVER_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;
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,423 @@
|
||||
/* 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_atomic_add;
|
||||
extern void * const z_impl_atomic_and;
|
||||
extern void * const z_impl_atomic_cas;
|
||||
extern void * const z_impl_atomic_nand;
|
||||
extern void * const z_impl_atomic_or;
|
||||
extern void * const z_impl_atomic_ptr_cas;
|
||||
extern void * const z_impl_atomic_ptr_set;
|
||||
extern void * const z_impl_atomic_set;
|
||||
extern void * const z_impl_atomic_sub;
|
||||
extern void * const z_impl_atomic_xor;
|
||||
extern void * const z_impl_can_add_rx_filter_msgq;
|
||||
extern void * const z_impl_can_calc_timing;
|
||||
extern void * const z_impl_can_calc_timing_data;
|
||||
extern void * const z_impl_can_get_bitrate_max;
|
||||
extern void * const z_impl_can_get_bitrate_min;
|
||||
extern void * const z_impl_can_get_capabilities;
|
||||
extern void * const z_impl_can_get_core_clock;
|
||||
extern void * const z_impl_can_get_max_filters;
|
||||
extern void * const z_impl_can_get_mode;
|
||||
extern void * const z_impl_can_get_state;
|
||||
extern void * const z_impl_can_get_timing_data_max;
|
||||
extern void * const z_impl_can_get_timing_data_min;
|
||||
extern void * const z_impl_can_get_timing_max;
|
||||
extern void * const z_impl_can_get_timing_min;
|
||||
extern void * const z_impl_can_get_transceiver;
|
||||
extern void * const z_impl_can_recover;
|
||||
extern void * const z_impl_can_remove_rx_filter;
|
||||
extern void * const z_impl_can_send;
|
||||
extern void * const z_impl_can_set_bitrate;
|
||||
extern void * const z_impl_can_set_bitrate_data;
|
||||
extern void * const z_impl_can_set_mode;
|
||||
extern void * const z_impl_can_set_timing;
|
||||
extern void * const z_impl_can_set_timing_data;
|
||||
extern void * const z_impl_can_start;
|
||||
extern void * const z_impl_can_stats_get_ack_errors;
|
||||
extern void * const z_impl_can_stats_get_bit0_errors;
|
||||
extern void * const z_impl_can_stats_get_bit1_errors;
|
||||
extern void * const z_impl_can_stats_get_bit_errors;
|
||||
extern void * const z_impl_can_stats_get_crc_errors;
|
||||
extern void * const z_impl_can_stats_get_form_errors;
|
||||
extern void * const z_impl_can_stats_get_rx_overruns;
|
||||
extern void * const z_impl_can_stats_get_stuff_errors;
|
||||
extern void * const z_impl_can_stop;
|
||||
extern void * const z_impl_device_deinit;
|
||||
extern void * const z_impl_device_get_binding;
|
||||
extern void * const z_impl_device_get_by_dt_nodelabel;
|
||||
extern void * const z_impl_device_init;
|
||||
extern void * const z_impl_device_is_ready;
|
||||
extern void * const z_impl_gpio_get_pending_int;
|
||||
extern void * const z_impl_gpio_pin_configure;
|
||||
extern void * const z_impl_gpio_pin_get_config;
|
||||
extern void * const z_impl_gpio_pin_interrupt_configure;
|
||||
extern void * const z_impl_gpio_port_clear_bits_raw;
|
||||
extern void * const z_impl_gpio_port_get_direction;
|
||||
extern void * const z_impl_gpio_port_get_raw;
|
||||
extern void * const z_impl_gpio_port_set_bits_raw;
|
||||
extern void * const z_impl_gpio_port_set_masked_raw;
|
||||
extern void * const z_impl_gpio_port_toggle_bits;
|
||||
extern void * const z_impl_hwinfo_clear_reset_cause;
|
||||
extern void * const z_impl_hwinfo_get_device_eui64;
|
||||
extern void * const z_impl_hwinfo_get_device_id;
|
||||
extern void * const z_impl_hwinfo_get_reset_cause;
|
||||
extern void * const z_impl_hwinfo_get_supported_reset_cause;
|
||||
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_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_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_reset_line_assert;
|
||||
extern void * const z_impl_reset_line_deassert;
|
||||
extern void * const z_impl_reset_line_toggle;
|
||||
extern void * const z_impl_reset_status;
|
||||
extern void * const z_impl_sys_clock_getrtoffset;
|
||||
extern void * const z_impl_sys_clock_hw_cycles_per_sec_runtime_get;
|
||||
extern void * const z_impl_sys_clock_nanosleep;
|
||||
extern void * const z_impl_sys_clock_settime;
|
||||
extern void * const z_impl_uart_config_get;
|
||||
extern void * const z_impl_uart_configure;
|
||||
extern void * const z_impl_uart_drv_cmd;
|
||||
extern void * const z_impl_uart_err_check;
|
||||
extern void * const z_impl_uart_irq_err_disable;
|
||||
extern void * const z_impl_uart_irq_err_enable;
|
||||
extern void * const z_impl_uart_irq_is_pending;
|
||||
extern void * const z_impl_uart_irq_rx_disable;
|
||||
extern void * const z_impl_uart_irq_rx_enable;
|
||||
extern void * const z_impl_uart_irq_tx_disable;
|
||||
extern void * const z_impl_uart_irq_tx_enable;
|
||||
extern void * const z_impl_uart_irq_update;
|
||||
extern void * const z_impl_uart_line_ctrl_get;
|
||||
extern void * const z_impl_uart_line_ctrl_set;
|
||||
extern void * const z_impl_uart_poll_in;
|
||||
extern void * const z_impl_uart_poll_in_u16;
|
||||
extern void * const z_impl_uart_poll_out;
|
||||
extern void * const z_impl_uart_poll_out_u16;
|
||||
extern void * const z_impl_uart_rx_disable;
|
||||
extern void * const z_impl_uart_rx_enable;
|
||||
extern void * const z_impl_uart_rx_enable_u16;
|
||||
extern void * const z_impl_uart_tx;
|
||||
extern void * const z_impl_uart_tx_abort;
|
||||
extern void * const z_impl_uart_tx_u16;
|
||||
extern void * const z_impl_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_SYMBOL(z_impl_atomic_add);
|
||||
EXPORT_SYMBOL(z_impl_atomic_and);
|
||||
EXPORT_SYMBOL(z_impl_atomic_cas);
|
||||
EXPORT_SYMBOL(z_impl_atomic_nand);
|
||||
EXPORT_SYMBOL(z_impl_atomic_or);
|
||||
EXPORT_SYMBOL(z_impl_atomic_ptr_cas);
|
||||
EXPORT_SYMBOL(z_impl_atomic_ptr_set);
|
||||
EXPORT_SYMBOL(z_impl_atomic_set);
|
||||
EXPORT_SYMBOL(z_impl_atomic_sub);
|
||||
EXPORT_SYMBOL(z_impl_atomic_xor);
|
||||
EXPORT_SYMBOL(z_impl_can_add_rx_filter_msgq);
|
||||
EXPORT_SYMBOL(z_impl_can_calc_timing);
|
||||
EXPORT_SYMBOL(z_impl_can_calc_timing_data);
|
||||
EXPORT_SYMBOL(z_impl_can_get_bitrate_max);
|
||||
EXPORT_SYMBOL(z_impl_can_get_bitrate_min);
|
||||
EXPORT_SYMBOL(z_impl_can_get_capabilities);
|
||||
EXPORT_SYMBOL(z_impl_can_get_core_clock);
|
||||
EXPORT_SYMBOL(z_impl_can_get_max_filters);
|
||||
EXPORT_SYMBOL(z_impl_can_get_mode);
|
||||
EXPORT_SYMBOL(z_impl_can_get_state);
|
||||
EXPORT_SYMBOL(z_impl_can_get_timing_data_max);
|
||||
EXPORT_SYMBOL(z_impl_can_get_timing_data_min);
|
||||
EXPORT_SYMBOL(z_impl_can_get_timing_max);
|
||||
EXPORT_SYMBOL(z_impl_can_get_timing_min);
|
||||
EXPORT_SYMBOL(z_impl_can_get_transceiver);
|
||||
EXPORT_SYMBOL(z_impl_can_recover);
|
||||
EXPORT_SYMBOL(z_impl_can_remove_rx_filter);
|
||||
EXPORT_SYMBOL(z_impl_can_send);
|
||||
EXPORT_SYMBOL(z_impl_can_set_bitrate);
|
||||
EXPORT_SYMBOL(z_impl_can_set_bitrate_data);
|
||||
EXPORT_SYMBOL(z_impl_can_set_mode);
|
||||
EXPORT_SYMBOL(z_impl_can_set_timing);
|
||||
EXPORT_SYMBOL(z_impl_can_set_timing_data);
|
||||
EXPORT_SYMBOL(z_impl_can_start);
|
||||
EXPORT_SYMBOL(z_impl_can_stats_get_ack_errors);
|
||||
EXPORT_SYMBOL(z_impl_can_stats_get_bit0_errors);
|
||||
EXPORT_SYMBOL(z_impl_can_stats_get_bit1_errors);
|
||||
EXPORT_SYMBOL(z_impl_can_stats_get_bit_errors);
|
||||
EXPORT_SYMBOL(z_impl_can_stats_get_crc_errors);
|
||||
EXPORT_SYMBOL(z_impl_can_stats_get_form_errors);
|
||||
EXPORT_SYMBOL(z_impl_can_stats_get_rx_overruns);
|
||||
EXPORT_SYMBOL(z_impl_can_stats_get_stuff_errors);
|
||||
EXPORT_SYMBOL(z_impl_can_stop);
|
||||
EXPORT_SYMBOL(z_impl_device_deinit);
|
||||
EXPORT_SYMBOL(z_impl_device_get_binding);
|
||||
EXPORT_SYMBOL(z_impl_device_get_by_dt_nodelabel);
|
||||
EXPORT_SYMBOL(z_impl_device_init);
|
||||
EXPORT_SYMBOL(z_impl_device_is_ready);
|
||||
EXPORT_SYMBOL(z_impl_gpio_get_pending_int);
|
||||
EXPORT_SYMBOL(z_impl_gpio_pin_configure);
|
||||
EXPORT_SYMBOL(z_impl_gpio_pin_get_config);
|
||||
EXPORT_SYMBOL(z_impl_gpio_pin_interrupt_configure);
|
||||
EXPORT_SYMBOL(z_impl_gpio_port_clear_bits_raw);
|
||||
EXPORT_SYMBOL(z_impl_gpio_port_get_direction);
|
||||
EXPORT_SYMBOL(z_impl_gpio_port_get_raw);
|
||||
EXPORT_SYMBOL(z_impl_gpio_port_set_bits_raw);
|
||||
EXPORT_SYMBOL(z_impl_gpio_port_set_masked_raw);
|
||||
EXPORT_SYMBOL(z_impl_gpio_port_toggle_bits);
|
||||
EXPORT_SYMBOL(z_impl_hwinfo_clear_reset_cause);
|
||||
EXPORT_SYMBOL(z_impl_hwinfo_get_device_eui64);
|
||||
EXPORT_SYMBOL(z_impl_hwinfo_get_device_id);
|
||||
EXPORT_SYMBOL(z_impl_hwinfo_get_reset_cause);
|
||||
EXPORT_SYMBOL(z_impl_hwinfo_get_supported_reset_cause);
|
||||
EXPORT_SYMBOL(z_impl_k_busy_wait);
|
||||
EXPORT_SYMBOL(z_impl_k_condvar_broadcast);
|
||||
EXPORT_SYMBOL(z_impl_k_condvar_init);
|
||||
EXPORT_SYMBOL(z_impl_k_condvar_signal);
|
||||
EXPORT_SYMBOL(z_impl_k_condvar_wait);
|
||||
EXPORT_SYMBOL(z_impl_k_event_clear);
|
||||
EXPORT_SYMBOL(z_impl_k_event_init);
|
||||
EXPORT_SYMBOL(z_impl_k_event_post);
|
||||
EXPORT_SYMBOL(z_impl_k_event_set);
|
||||
EXPORT_SYMBOL(z_impl_k_event_set_masked);
|
||||
EXPORT_SYMBOL(z_impl_k_event_wait);
|
||||
EXPORT_SYMBOL(z_impl_k_event_wait_all);
|
||||
EXPORT_SYMBOL(z_impl_k_event_wait_all_safe);
|
||||
EXPORT_SYMBOL(z_impl_k_event_wait_safe);
|
||||
EXPORT_SYMBOL(z_impl_k_float_disable);
|
||||
EXPORT_SYMBOL(z_impl_k_float_enable);
|
||||
EXPORT_SYMBOL(z_impl_k_futex_wait);
|
||||
EXPORT_SYMBOL(z_impl_k_futex_wake);
|
||||
EXPORT_SYMBOL(z_impl_k_is_preempt_thread);
|
||||
EXPORT_SYMBOL(z_impl_k_msgq_alloc_init);
|
||||
EXPORT_SYMBOL(z_impl_k_msgq_get);
|
||||
EXPORT_SYMBOL(z_impl_k_msgq_get_attrs);
|
||||
EXPORT_SYMBOL(z_impl_k_msgq_num_free_get);
|
||||
EXPORT_SYMBOL(z_impl_k_msgq_num_used_get);
|
||||
EXPORT_SYMBOL(z_impl_k_msgq_peek);
|
||||
EXPORT_SYMBOL(z_impl_k_msgq_peek_at);
|
||||
EXPORT_SYMBOL(z_impl_k_msgq_purge);
|
||||
EXPORT_SYMBOL(z_impl_k_msgq_put);
|
||||
EXPORT_SYMBOL(z_impl_k_msgq_put_front);
|
||||
EXPORT_SYMBOL(z_impl_k_mutex_init);
|
||||
EXPORT_SYMBOL(z_impl_k_mutex_lock);
|
||||
EXPORT_SYMBOL(z_impl_k_mutex_unlock);
|
||||
EXPORT_SYMBOL(z_impl_k_object_access_grant);
|
||||
EXPORT_SYMBOL(z_impl_k_object_alloc);
|
||||
EXPORT_SYMBOL(z_impl_k_object_alloc_size);
|
||||
EXPORT_SYMBOL(z_impl_k_object_release);
|
||||
EXPORT_SYMBOL(z_impl_k_pipe_close);
|
||||
EXPORT_SYMBOL(z_impl_k_pipe_init);
|
||||
EXPORT_SYMBOL(z_impl_k_pipe_read);
|
||||
EXPORT_SYMBOL(z_impl_k_pipe_reset);
|
||||
EXPORT_SYMBOL(z_impl_k_pipe_write);
|
||||
EXPORT_SYMBOL(z_impl_k_poll);
|
||||
EXPORT_SYMBOL(z_impl_k_poll_signal_check);
|
||||
EXPORT_SYMBOL(z_impl_k_poll_signal_init);
|
||||
EXPORT_SYMBOL(z_impl_k_poll_signal_raise);
|
||||
EXPORT_SYMBOL(z_impl_k_poll_signal_reset);
|
||||
EXPORT_SYMBOL(z_impl_k_queue_alloc_append);
|
||||
EXPORT_SYMBOL(z_impl_k_queue_alloc_prepend);
|
||||
EXPORT_SYMBOL(z_impl_k_queue_cancel_wait);
|
||||
EXPORT_SYMBOL(z_impl_k_queue_get);
|
||||
EXPORT_SYMBOL(z_impl_k_queue_init);
|
||||
EXPORT_SYMBOL(z_impl_k_queue_is_empty);
|
||||
EXPORT_SYMBOL(z_impl_k_queue_peek_head);
|
||||
EXPORT_SYMBOL(z_impl_k_queue_peek_tail);
|
||||
EXPORT_SYMBOL(z_impl_k_reschedule);
|
||||
EXPORT_SYMBOL(z_impl_k_sched_current_thread_query);
|
||||
EXPORT_SYMBOL(z_impl_k_sem_count_get);
|
||||
EXPORT_SYMBOL(z_impl_k_sem_give);
|
||||
EXPORT_SYMBOL(z_impl_k_sem_init);
|
||||
EXPORT_SYMBOL(z_impl_k_sem_reset);
|
||||
EXPORT_SYMBOL(z_impl_k_sem_take);
|
||||
EXPORT_SYMBOL(z_impl_k_sleep);
|
||||
EXPORT_SYMBOL(z_impl_k_stack_alloc_init);
|
||||
EXPORT_SYMBOL(z_impl_k_stack_pop);
|
||||
EXPORT_SYMBOL(z_impl_k_stack_push);
|
||||
EXPORT_SYMBOL(z_impl_k_str_out);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_abort);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_absolute_deadline_set);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_create);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_custom_data_get);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_custom_data_set);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_deadline_set);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_join);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_name_copy);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_name_set);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_priority_get);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_priority_set);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_resume);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_stack_alloc);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_stack_free);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_stack_space_get);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_suspend);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_timeout_expires_ticks);
|
||||
EXPORT_SYMBOL(z_impl_k_thread_timeout_remaining_ticks);
|
||||
EXPORT_SYMBOL(z_impl_k_timer_expires_ticks);
|
||||
EXPORT_SYMBOL(z_impl_k_timer_remaining_ticks);
|
||||
EXPORT_SYMBOL(z_impl_k_timer_start);
|
||||
EXPORT_SYMBOL(z_impl_k_timer_status_get);
|
||||
EXPORT_SYMBOL(z_impl_k_timer_status_sync);
|
||||
EXPORT_SYMBOL(z_impl_k_timer_stop);
|
||||
EXPORT_SYMBOL(z_impl_k_timer_user_data_get);
|
||||
EXPORT_SYMBOL(z_impl_k_timer_user_data_set);
|
||||
EXPORT_SYMBOL(z_impl_k_uptime_ticks);
|
||||
EXPORT_SYMBOL(z_impl_k_usleep);
|
||||
EXPORT_SYMBOL(z_impl_k_wakeup);
|
||||
EXPORT_SYMBOL(z_impl_k_yield);
|
||||
EXPORT_SYMBOL(z_impl_log_buffered_cnt);
|
||||
EXPORT_SYMBOL(z_impl_log_filter_set);
|
||||
EXPORT_SYMBOL(z_impl_log_frontend_filter_set);
|
||||
EXPORT_SYMBOL(z_impl_log_panic);
|
||||
EXPORT_SYMBOL(z_impl_log_process);
|
||||
EXPORT_SYMBOL(z_impl_reset_line_assert);
|
||||
EXPORT_SYMBOL(z_impl_reset_line_deassert);
|
||||
EXPORT_SYMBOL(z_impl_reset_line_toggle);
|
||||
EXPORT_SYMBOL(z_impl_reset_status);
|
||||
EXPORT_SYMBOL(z_impl_sys_clock_getrtoffset);
|
||||
EXPORT_SYMBOL(z_impl_sys_clock_hw_cycles_per_sec_runtime_get);
|
||||
EXPORT_SYMBOL(z_impl_sys_clock_nanosleep);
|
||||
EXPORT_SYMBOL(z_impl_sys_clock_settime);
|
||||
EXPORT_SYMBOL(z_impl_uart_config_get);
|
||||
EXPORT_SYMBOL(z_impl_uart_configure);
|
||||
EXPORT_SYMBOL(z_impl_uart_drv_cmd);
|
||||
EXPORT_SYMBOL(z_impl_uart_err_check);
|
||||
EXPORT_SYMBOL(z_impl_uart_irq_err_disable);
|
||||
EXPORT_SYMBOL(z_impl_uart_irq_err_enable);
|
||||
EXPORT_SYMBOL(z_impl_uart_irq_is_pending);
|
||||
EXPORT_SYMBOL(z_impl_uart_irq_rx_disable);
|
||||
EXPORT_SYMBOL(z_impl_uart_irq_rx_enable);
|
||||
EXPORT_SYMBOL(z_impl_uart_irq_tx_disable);
|
||||
EXPORT_SYMBOL(z_impl_uart_irq_tx_enable);
|
||||
EXPORT_SYMBOL(z_impl_uart_irq_update);
|
||||
EXPORT_SYMBOL(z_impl_uart_line_ctrl_get);
|
||||
EXPORT_SYMBOL(z_impl_uart_line_ctrl_set);
|
||||
EXPORT_SYMBOL(z_impl_uart_poll_in);
|
||||
EXPORT_SYMBOL(z_impl_uart_poll_in_u16);
|
||||
EXPORT_SYMBOL(z_impl_uart_poll_out);
|
||||
EXPORT_SYMBOL(z_impl_uart_poll_out_u16);
|
||||
EXPORT_SYMBOL(z_impl_uart_rx_disable);
|
||||
EXPORT_SYMBOL(z_impl_uart_rx_enable);
|
||||
EXPORT_SYMBOL(z_impl_uart_rx_enable_u16);
|
||||
EXPORT_SYMBOL(z_impl_uart_tx);
|
||||
EXPORT_SYMBOL(z_impl_uart_tx_abort);
|
||||
EXPORT_SYMBOL(z_impl_uart_tx_u16);
|
||||
EXPORT_SYMBOL(z_impl_z_log_msg_simple_create_0);
|
||||
EXPORT_SYMBOL(z_impl_z_log_msg_simple_create_1);
|
||||
EXPORT_SYMBOL(z_impl_z_log_msg_simple_create_2);
|
||||
EXPORT_SYMBOL(z_impl_z_log_msg_static_create);
|
||||
EXPORT_SYMBOL(z_impl_z_sys_mutex_kernel_lock);
|
||||
EXPORT_SYMBOL(z_impl_z_sys_mutex_kernel_unlock);
|
||||
EXPORT_SYMBOL(z_impl_zephyr_fputc);
|
||||
EXPORT_SYMBOL(z_impl_zephyr_fwrite);
|
||||
EXPORT_SYMBOL(z_impl_zephyr_read_stdin);
|
||||
EXPORT_SYMBOL(z_impl_zephyr_write_stdout);
|
||||
@@ -0,0 +1,604 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef ZEPHYR_SYSCALL_LIST_H
|
||||
#define ZEPHYR_SYSCALL_LIST_H
|
||||
|
||||
#define K_SYSCALL_ATOMIC_ADD 0
|
||||
#define K_SYSCALL_ATOMIC_AND 1
|
||||
#define K_SYSCALL_ATOMIC_CAS 2
|
||||
#define K_SYSCALL_ATOMIC_NAND 3
|
||||
#define K_SYSCALL_ATOMIC_OR 4
|
||||
#define K_SYSCALL_ATOMIC_PTR_CAS 5
|
||||
#define K_SYSCALL_ATOMIC_PTR_SET 6
|
||||
#define K_SYSCALL_ATOMIC_SET 7
|
||||
#define K_SYSCALL_ATOMIC_SUB 8
|
||||
#define K_SYSCALL_ATOMIC_XOR 9
|
||||
#define K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ 10
|
||||
#define K_SYSCALL_CAN_CALC_TIMING 11
|
||||
#define K_SYSCALL_CAN_CALC_TIMING_DATA 12
|
||||
#define K_SYSCALL_CAN_GET_BITRATE_MAX 13
|
||||
#define K_SYSCALL_CAN_GET_BITRATE_MIN 14
|
||||
#define K_SYSCALL_CAN_GET_CAPABILITIES 15
|
||||
#define K_SYSCALL_CAN_GET_CORE_CLOCK 16
|
||||
#define K_SYSCALL_CAN_GET_MAX_FILTERS 17
|
||||
#define K_SYSCALL_CAN_GET_MODE 18
|
||||
#define K_SYSCALL_CAN_GET_STATE 19
|
||||
#define K_SYSCALL_CAN_GET_TIMING_DATA_MAX 20
|
||||
#define K_SYSCALL_CAN_GET_TIMING_DATA_MIN 21
|
||||
#define K_SYSCALL_CAN_GET_TIMING_MAX 22
|
||||
#define K_SYSCALL_CAN_GET_TIMING_MIN 23
|
||||
#define K_SYSCALL_CAN_GET_TRANSCEIVER 24
|
||||
#define K_SYSCALL_CAN_RECOVER 25
|
||||
#define K_SYSCALL_CAN_REMOVE_RX_FILTER 26
|
||||
#define K_SYSCALL_CAN_SEND 27
|
||||
#define K_SYSCALL_CAN_SET_BITRATE 28
|
||||
#define K_SYSCALL_CAN_SET_BITRATE_DATA 29
|
||||
#define K_SYSCALL_CAN_SET_MODE 30
|
||||
#define K_SYSCALL_CAN_SET_TIMING 31
|
||||
#define K_SYSCALL_CAN_SET_TIMING_DATA 32
|
||||
#define K_SYSCALL_CAN_START 33
|
||||
#define K_SYSCALL_CAN_STATS_GET_ACK_ERRORS 34
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS 35
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS 36
|
||||
#define K_SYSCALL_CAN_STATS_GET_BIT_ERRORS 37
|
||||
#define K_SYSCALL_CAN_STATS_GET_CRC_ERRORS 38
|
||||
#define K_SYSCALL_CAN_STATS_GET_FORM_ERRORS 39
|
||||
#define K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS 40
|
||||
#define K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS 41
|
||||
#define K_SYSCALL_CAN_STOP 42
|
||||
#define K_SYSCALL_DEVICE_DEINIT 43
|
||||
#define K_SYSCALL_DEVICE_GET_BINDING 44
|
||||
#define K_SYSCALL_DEVICE_GET_BY_DT_NODELABEL 45
|
||||
#define K_SYSCALL_DEVICE_INIT 46
|
||||
#define K_SYSCALL_DEVICE_IS_READY 47
|
||||
#define K_SYSCALL_GPIO_GET_PENDING_INT 48
|
||||
#define K_SYSCALL_GPIO_PIN_CONFIGURE 49
|
||||
#define K_SYSCALL_GPIO_PIN_GET_CONFIG 50
|
||||
#define K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE 51
|
||||
#define K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW 52
|
||||
#define K_SYSCALL_GPIO_PORT_GET_DIRECTION 53
|
||||
#define K_SYSCALL_GPIO_PORT_GET_RAW 54
|
||||
#define K_SYSCALL_GPIO_PORT_SET_BITS_RAW 55
|
||||
#define K_SYSCALL_GPIO_PORT_SET_MASKED_RAW 56
|
||||
#define K_SYSCALL_GPIO_PORT_TOGGLE_BITS 57
|
||||
#define K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE 58
|
||||
#define K_SYSCALL_HWINFO_GET_DEVICE_EUI64 59
|
||||
#define K_SYSCALL_HWINFO_GET_DEVICE_ID 60
|
||||
#define K_SYSCALL_HWINFO_GET_RESET_CAUSE 61
|
||||
#define K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE 62
|
||||
#define K_SYSCALL_K_BUSY_WAIT 63
|
||||
#define K_SYSCALL_K_CONDVAR_BROADCAST 64
|
||||
#define K_SYSCALL_K_CONDVAR_INIT 65
|
||||
#define K_SYSCALL_K_CONDVAR_SIGNAL 66
|
||||
#define K_SYSCALL_K_CONDVAR_WAIT 67
|
||||
#define K_SYSCALL_K_EVENT_CLEAR 68
|
||||
#define K_SYSCALL_K_EVENT_INIT 69
|
||||
#define K_SYSCALL_K_EVENT_POST 70
|
||||
#define K_SYSCALL_K_EVENT_SET 71
|
||||
#define K_SYSCALL_K_EVENT_SET_MASKED 72
|
||||
#define K_SYSCALL_K_EVENT_WAIT 73
|
||||
#define K_SYSCALL_K_EVENT_WAIT_ALL 74
|
||||
#define K_SYSCALL_K_EVENT_WAIT_ALL_SAFE 75
|
||||
#define K_SYSCALL_K_EVENT_WAIT_SAFE 76
|
||||
#define K_SYSCALL_K_FLOAT_DISABLE 77
|
||||
#define K_SYSCALL_K_FLOAT_ENABLE 78
|
||||
#define K_SYSCALL_K_FUTEX_WAIT 79
|
||||
#define K_SYSCALL_K_FUTEX_WAKE 80
|
||||
#define K_SYSCALL_K_IS_PREEMPT_THREAD 81
|
||||
#define K_SYSCALL_K_MSGQ_ALLOC_INIT 82
|
||||
#define K_SYSCALL_K_MSGQ_GET 83
|
||||
#define K_SYSCALL_K_MSGQ_GET_ATTRS 84
|
||||
#define K_SYSCALL_K_MSGQ_NUM_FREE_GET 85
|
||||
#define K_SYSCALL_K_MSGQ_NUM_USED_GET 86
|
||||
#define K_SYSCALL_K_MSGQ_PEEK 87
|
||||
#define K_SYSCALL_K_MSGQ_PEEK_AT 88
|
||||
#define K_SYSCALL_K_MSGQ_PURGE 89
|
||||
#define K_SYSCALL_K_MSGQ_PUT 90
|
||||
#define K_SYSCALL_K_MSGQ_PUT_FRONT 91
|
||||
#define K_SYSCALL_K_MUTEX_INIT 92
|
||||
#define K_SYSCALL_K_MUTEX_LOCK 93
|
||||
#define K_SYSCALL_K_MUTEX_UNLOCK 94
|
||||
#define K_SYSCALL_K_OBJECT_ACCESS_GRANT 95
|
||||
#define K_SYSCALL_K_OBJECT_ALLOC 96
|
||||
#define K_SYSCALL_K_OBJECT_ALLOC_SIZE 97
|
||||
#define K_SYSCALL_K_OBJECT_RELEASE 98
|
||||
#define K_SYSCALL_K_PIPE_CLOSE 99
|
||||
#define K_SYSCALL_K_PIPE_INIT 100
|
||||
#define K_SYSCALL_K_PIPE_READ 101
|
||||
#define K_SYSCALL_K_PIPE_RESET 102
|
||||
#define K_SYSCALL_K_PIPE_WRITE 103
|
||||
#define K_SYSCALL_K_POLL 104
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_CHECK 105
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_INIT 106
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_RAISE 107
|
||||
#define K_SYSCALL_K_POLL_SIGNAL_RESET 108
|
||||
#define K_SYSCALL_K_QUEUE_ALLOC_APPEND 109
|
||||
#define K_SYSCALL_K_QUEUE_ALLOC_PREPEND 110
|
||||
#define K_SYSCALL_K_QUEUE_CANCEL_WAIT 111
|
||||
#define K_SYSCALL_K_QUEUE_GET 112
|
||||
#define K_SYSCALL_K_QUEUE_INIT 113
|
||||
#define K_SYSCALL_K_QUEUE_IS_EMPTY 114
|
||||
#define K_SYSCALL_K_QUEUE_PEEK_HEAD 115
|
||||
#define K_SYSCALL_K_QUEUE_PEEK_TAIL 116
|
||||
#define K_SYSCALL_K_RESCHEDULE 117
|
||||
#define K_SYSCALL_K_SCHED_CURRENT_THREAD_QUERY 118
|
||||
#define K_SYSCALL_K_SEM_COUNT_GET 119
|
||||
#define K_SYSCALL_K_SEM_GIVE 120
|
||||
#define K_SYSCALL_K_SEM_INIT 121
|
||||
#define K_SYSCALL_K_SEM_RESET 122
|
||||
#define K_SYSCALL_K_SEM_TAKE 123
|
||||
#define K_SYSCALL_K_SLEEP 124
|
||||
#define K_SYSCALL_K_STACK_ALLOC_INIT 125
|
||||
#define K_SYSCALL_K_STACK_POP 126
|
||||
#define K_SYSCALL_K_STACK_PUSH 127
|
||||
#define K_SYSCALL_K_STR_OUT 128
|
||||
#define K_SYSCALL_K_THREAD_ABORT 129
|
||||
#define K_SYSCALL_K_THREAD_ABSOLUTE_DEADLINE_SET 130
|
||||
#define K_SYSCALL_K_THREAD_CREATE 131
|
||||
#define K_SYSCALL_K_THREAD_CUSTOM_DATA_GET 132
|
||||
#define K_SYSCALL_K_THREAD_CUSTOM_DATA_SET 133
|
||||
#define K_SYSCALL_K_THREAD_DEADLINE_SET 134
|
||||
#define K_SYSCALL_K_THREAD_JOIN 135
|
||||
#define K_SYSCALL_K_THREAD_NAME_COPY 136
|
||||
#define K_SYSCALL_K_THREAD_NAME_SET 137
|
||||
#define K_SYSCALL_K_THREAD_PRIORITY_GET 138
|
||||
#define K_SYSCALL_K_THREAD_PRIORITY_SET 139
|
||||
#define K_SYSCALL_K_THREAD_RESUME 140
|
||||
#define K_SYSCALL_K_THREAD_STACK_ALLOC 141
|
||||
#define K_SYSCALL_K_THREAD_STACK_FREE 142
|
||||
#define K_SYSCALL_K_THREAD_STACK_SPACE_GET 143
|
||||
#define K_SYSCALL_K_THREAD_SUSPEND 144
|
||||
#define K_SYSCALL_K_THREAD_TIMEOUT_EXPIRES_TICKS 145
|
||||
#define K_SYSCALL_K_THREAD_TIMEOUT_REMAINING_TICKS 146
|
||||
#define K_SYSCALL_K_TIMER_EXPIRES_TICKS 147
|
||||
#define K_SYSCALL_K_TIMER_REMAINING_TICKS 148
|
||||
#define K_SYSCALL_K_TIMER_START 149
|
||||
#define K_SYSCALL_K_TIMER_STATUS_GET 150
|
||||
#define K_SYSCALL_K_TIMER_STATUS_SYNC 151
|
||||
#define K_SYSCALL_K_TIMER_STOP 152
|
||||
#define K_SYSCALL_K_TIMER_USER_DATA_GET 153
|
||||
#define K_SYSCALL_K_TIMER_USER_DATA_SET 154
|
||||
#define K_SYSCALL_K_UPTIME_TICKS 155
|
||||
#define K_SYSCALL_K_USLEEP 156
|
||||
#define K_SYSCALL_K_WAKEUP 157
|
||||
#define K_SYSCALL_K_YIELD 158
|
||||
#define K_SYSCALL_LOG_BUFFERED_CNT 159
|
||||
#define K_SYSCALL_LOG_FILTER_SET 160
|
||||
#define K_SYSCALL_LOG_FRONTEND_FILTER_SET 161
|
||||
#define K_SYSCALL_LOG_PANIC 162
|
||||
#define K_SYSCALL_LOG_PROCESS 163
|
||||
#define K_SYSCALL_RESET_LINE_ASSERT 164
|
||||
#define K_SYSCALL_RESET_LINE_DEASSERT 165
|
||||
#define K_SYSCALL_RESET_LINE_TOGGLE 166
|
||||
#define K_SYSCALL_RESET_STATUS 167
|
||||
#define K_SYSCALL_SYS_CLOCK_GETRTOFFSET 168
|
||||
#define K_SYSCALL_SYS_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_GET 169
|
||||
#define K_SYSCALL_SYS_CLOCK_NANOSLEEP 170
|
||||
#define K_SYSCALL_SYS_CLOCK_SETTIME 171
|
||||
#define K_SYSCALL_UART_CONFIGURE 172
|
||||
#define K_SYSCALL_UART_CONFIG_GET 173
|
||||
#define K_SYSCALL_UART_DRV_CMD 174
|
||||
#define K_SYSCALL_UART_ERR_CHECK 175
|
||||
#define K_SYSCALL_UART_IRQ_ERR_DISABLE 176
|
||||
#define K_SYSCALL_UART_IRQ_ERR_ENABLE 177
|
||||
#define K_SYSCALL_UART_IRQ_IS_PENDING 178
|
||||
#define K_SYSCALL_UART_IRQ_RX_DISABLE 179
|
||||
#define K_SYSCALL_UART_IRQ_RX_ENABLE 180
|
||||
#define K_SYSCALL_UART_IRQ_TX_DISABLE 181
|
||||
#define K_SYSCALL_UART_IRQ_TX_ENABLE 182
|
||||
#define K_SYSCALL_UART_IRQ_UPDATE 183
|
||||
#define K_SYSCALL_UART_LINE_CTRL_GET 184
|
||||
#define K_SYSCALL_UART_LINE_CTRL_SET 185
|
||||
#define K_SYSCALL_UART_POLL_IN 186
|
||||
#define K_SYSCALL_UART_POLL_IN_U16 187
|
||||
#define K_SYSCALL_UART_POLL_OUT 188
|
||||
#define K_SYSCALL_UART_POLL_OUT_U16 189
|
||||
#define K_SYSCALL_UART_RX_DISABLE 190
|
||||
#define K_SYSCALL_UART_RX_ENABLE 191
|
||||
#define K_SYSCALL_UART_RX_ENABLE_U16 192
|
||||
#define K_SYSCALL_UART_TX 193
|
||||
#define K_SYSCALL_UART_TX_ABORT 194
|
||||
#define K_SYSCALL_UART_TX_U16 195
|
||||
#define K_SYSCALL_ZEPHYR_FPUTC 196
|
||||
#define K_SYSCALL_ZEPHYR_FWRITE 197
|
||||
#define K_SYSCALL_ZEPHYR_READ_STDIN 198
|
||||
#define K_SYSCALL_ZEPHYR_WRITE_STDOUT 199
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0 200
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1 201
|
||||
#define K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2 202
|
||||
#define K_SYSCALL_Z_LOG_MSG_STATIC_CREATE 203
|
||||
#define K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK 204
|
||||
#define K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK 205
|
||||
#define K_SYSCALL_BAD 206
|
||||
#define K_SYSCALL_LIMIT 207
|
||||
|
||||
|
||||
/* Following syscalls are not used in image */
|
||||
#define K_SYSCALL_ADC_CHANNEL_SETUP 208
|
||||
#define K_SYSCALL_ADC_GET_DECODER 209
|
||||
#define K_SYSCALL_ADC_READ 210
|
||||
#define K_SYSCALL_ADC_READ_ASYNC 211
|
||||
#define K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET 212
|
||||
#define K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET 213
|
||||
#define K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET 214
|
||||
#define K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET 215
|
||||
#define K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET 216
|
||||
#define K_SYSCALL_AUXDISPLAY_CLEAR 217
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET 218
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET 219
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED 220
|
||||
#define K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET 221
|
||||
#define K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET 222
|
||||
#define K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND 223
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_OFF 224
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_ON 225
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET 226
|
||||
#define K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET 227
|
||||
#define K_SYSCALL_AUXDISPLAY_IS_BUSY 228
|
||||
#define K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED 229
|
||||
#define K_SYSCALL_AUXDISPLAY_WRITE 230
|
||||
#define K_SYSCALL_BBRAM_CHECK_INVALID 231
|
||||
#define K_SYSCALL_BBRAM_CHECK_POWER 232
|
||||
#define K_SYSCALL_BBRAM_CHECK_STANDBY_POWER 233
|
||||
#define K_SYSCALL_BBRAM_GET_SIZE 234
|
||||
#define K_SYSCALL_BBRAM_READ 235
|
||||
#define K_SYSCALL_BBRAM_WRITE 236
|
||||
#define K_SYSCALL_BC12_SET_RESULT_CB 237
|
||||
#define K_SYSCALL_BC12_SET_ROLE 238
|
||||
#define K_SYSCALL_CHARGER_CHARGE_ENABLE 239
|
||||
#define K_SYSCALL_CHARGER_GET_PROP 240
|
||||
#define K_SYSCALL_CHARGER_SET_PROP 241
|
||||
#define K_SYSCALL_COMPARATOR_GET_OUTPUT 242
|
||||
#define K_SYSCALL_COMPARATOR_SET_TRIGGER 243
|
||||
#define K_SYSCALL_COMPARATOR_TRIGGER_IS_PENDING 244
|
||||
#define K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM 245
|
||||
#define K_SYSCALL_COUNTER_GET_FREQUENCY 246
|
||||
#define K_SYSCALL_COUNTER_GET_GUARD_PERIOD 247
|
||||
#define K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE 248
|
||||
#define K_SYSCALL_COUNTER_GET_NUM_OF_CHANNELS 249
|
||||
#define K_SYSCALL_COUNTER_GET_PENDING_INT 250
|
||||
#define K_SYSCALL_COUNTER_GET_TOP_VALUE 251
|
||||
#define K_SYSCALL_COUNTER_GET_VALUE 252
|
||||
#define K_SYSCALL_COUNTER_GET_VALUE_64 253
|
||||
#define K_SYSCALL_COUNTER_IS_COUNTING_UP 254
|
||||
#define K_SYSCALL_COUNTER_RESET 255
|
||||
#define K_SYSCALL_COUNTER_SET_CHANNEL_ALARM 256
|
||||
#define K_SYSCALL_COUNTER_SET_GUARD_PERIOD 257
|
||||
#define K_SYSCALL_COUNTER_SET_TOP_VALUE 258
|
||||
#define K_SYSCALL_COUNTER_START 259
|
||||
#define K_SYSCALL_COUNTER_STOP 260
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_NS 261
|
||||
#define K_SYSCALL_COUNTER_TICKS_TO_US 262
|
||||
#define K_SYSCALL_COUNTER_US_TO_TICKS 263
|
||||
#define K_SYSCALL_CRC_BEGIN 264
|
||||
#define K_SYSCALL_CRC_FINISH 265
|
||||
#define K_SYSCALL_CRC_UPDATE 266
|
||||
#define K_SYSCALL_DAC_CHANNEL_SETUP 267
|
||||
#define K_SYSCALL_DAC_WRITE_VALUE 268
|
||||
#define K_SYSCALL_DEVMUX_SELECT_GET 269
|
||||
#define K_SYSCALL_DEVMUX_SELECT_SET 270
|
||||
#define K_SYSCALL_EEPROM_GET_SIZE 271
|
||||
#define K_SYSCALL_EEPROM_READ 272
|
||||
#define K_SYSCALL_EEPROM_WRITE 273
|
||||
#define K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF 274
|
||||
#define K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING 275
|
||||
#define K_SYSCALL_ENTROPY_GET_ENTROPY 276
|
||||
#define K_SYSCALL_ESPI_CONFIG 277
|
||||
#define K_SYSCALL_ESPI_FLASH_ERASE 278
|
||||
#define K_SYSCALL_ESPI_GET_CHANNEL_STATUS 279
|
||||
#define K_SYSCALL_ESPI_READ_FLASH 280
|
||||
#define K_SYSCALL_ESPI_READ_LPC_REQUEST 281
|
||||
#define K_SYSCALL_ESPI_READ_REQUEST 282
|
||||
#define K_SYSCALL_ESPI_RECEIVE_OOB 283
|
||||
#define K_SYSCALL_ESPI_RECEIVE_VWIRE 284
|
||||
#define K_SYSCALL_ESPI_SAF_ACTIVATE 285
|
||||
#define K_SYSCALL_ESPI_SAF_CONFIG 286
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_ERASE 287
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_READ 288
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS 289
|
||||
#define K_SYSCALL_ESPI_SAF_FLASH_WRITE 290
|
||||
#define K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS 291
|
||||
#define K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS 292
|
||||
#define K_SYSCALL_ESPI_SEND_OOB 293
|
||||
#define K_SYSCALL_ESPI_SEND_VWIRE 294
|
||||
#define K_SYSCALL_ESPI_WRITE_FLASH 295
|
||||
#define K_SYSCALL_ESPI_WRITE_LPC_REQUEST 296
|
||||
#define K_SYSCALL_ESPI_WRITE_REQUEST 297
|
||||
#define K_SYSCALL_FLASH_COPY 298
|
||||
#define K_SYSCALL_FLASH_ERASE 299
|
||||
#define K_SYSCALL_FLASH_EX_OP 300
|
||||
#define K_SYSCALL_FLASH_FILL 301
|
||||
#define K_SYSCALL_FLASH_FLATTEN 302
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_COUNT 303
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX 304
|
||||
#define K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS 305
|
||||
#define K_SYSCALL_FLASH_GET_PARAMETERS 306
|
||||
#define K_SYSCALL_FLASH_GET_SIZE 307
|
||||
#define K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE 308
|
||||
#define K_SYSCALL_FLASH_READ 309
|
||||
#define K_SYSCALL_FLASH_READ_JEDEC_ID 310
|
||||
#define K_SYSCALL_FLASH_SFDP_READ 311
|
||||
#define K_SYSCALL_FLASH_SIMULATOR_GET_MEMORY 312
|
||||
#define K_SYSCALL_FLASH_WRITE 313
|
||||
#define K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF 314
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP 315
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_PROP 316
|
||||
#define K_SYSCALL_FUEL_GAUGE_GET_PROPS 317
|
||||
#define K_SYSCALL_FUEL_GAUGE_SET_PROP 318
|
||||
#define K_SYSCALL_FUEL_GAUGE_SET_PROPS 319
|
||||
#define K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS 320
|
||||
#define K_SYSCALL_GNSS_GET_FIX_RATE 321
|
||||
#define K_SYSCALL_GNSS_GET_LATEST_TIMEPULSE 322
|
||||
#define K_SYSCALL_GNSS_GET_NAVIGATION_MODE 323
|
||||
#define K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS 324
|
||||
#define K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS 325
|
||||
#define K_SYSCALL_GNSS_SET_FIX_RATE 326
|
||||
#define K_SYSCALL_GNSS_SET_NAVIGATION_MODE 327
|
||||
#define K_SYSCALL_HAPTICS_START_OUTPUT 328
|
||||
#define K_SYSCALL_HAPTICS_STOP_OUTPUT 329
|
||||
#define K_SYSCALL_I2C_CONFIGURE 330
|
||||
#define K_SYSCALL_I2C_GET_CONFIG 331
|
||||
#define K_SYSCALL_I2C_RECOVER_BUS 332
|
||||
#define K_SYSCALL_I2C_TARGET_DRIVER_REGISTER 333
|
||||
#define K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER 334
|
||||
#define K_SYSCALL_I2C_TRANSFER 335
|
||||
#define K_SYSCALL_I2S_BUF_READ 336
|
||||
#define K_SYSCALL_I2S_BUF_WRITE 337
|
||||
#define K_SYSCALL_I2S_CONFIGURE 338
|
||||
#define K_SYSCALL_I2S_TRIGGER 339
|
||||
#define K_SYSCALL_I3C_DO_CCC 340
|
||||
#define K_SYSCALL_I3C_TRANSFER 341
|
||||
#define K_SYSCALL_IPM_COMPLETE 342
|
||||
#define K_SYSCALL_IPM_MAX_DATA_SIZE_GET 343
|
||||
#define K_SYSCALL_IPM_MAX_ID_VAL_GET 344
|
||||
#define K_SYSCALL_IPM_SEND 345
|
||||
#define K_SYSCALL_IPM_SET_ENABLED 346
|
||||
#define K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS 347
|
||||
#define K_SYSCALL_IVSHMEM_GET_ID 348
|
||||
#define K_SYSCALL_IVSHMEM_GET_MAX_PEERS 349
|
||||
#define K_SYSCALL_IVSHMEM_GET_MEM 350
|
||||
#define K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION 351
|
||||
#define K_SYSCALL_IVSHMEM_GET_PROTOCOL 352
|
||||
#define K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION 353
|
||||
#define K_SYSCALL_IVSHMEM_GET_STATE 354
|
||||
#define K_SYSCALL_IVSHMEM_GET_VECTORS 355
|
||||
#define K_SYSCALL_IVSHMEM_INT_PEER 356
|
||||
#define K_SYSCALL_IVSHMEM_REGISTER_HANDLER 357
|
||||
#define K_SYSCALL_IVSHMEM_SET_STATE 358
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET 359
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET 360
|
||||
#define K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET 361
|
||||
#define K_SYSCALL_K_MEM_PAGING_STATS_GET 362
|
||||
#define K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET 363
|
||||
#define K_SYSCALL_LED_BLINK 364
|
||||
#define K_SYSCALL_LED_GET_INFO 365
|
||||
#define K_SYSCALL_LED_OFF 366
|
||||
#define K_SYSCALL_LED_ON 367
|
||||
#define K_SYSCALL_LED_SET_BRIGHTNESS 368
|
||||
#define K_SYSCALL_LED_SET_CHANNEL 369
|
||||
#define K_SYSCALL_LED_SET_COLOR 370
|
||||
#define K_SYSCALL_LED_WRITE_CHANNELS 371
|
||||
#define K_SYSCALL_LLEXT_GET_FN_TABLE 372
|
||||
#define K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT 373
|
||||
#define K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT 374
|
||||
#define K_SYSCALL_MBOX_MAX_CHANNELS_GET 375
|
||||
#define K_SYSCALL_MBOX_MTU_GET 376
|
||||
#define K_SYSCALL_MBOX_SEND 377
|
||||
#define K_SYSCALL_MBOX_SET_ENABLED 378
|
||||
#define K_SYSCALL_MDIO_BUS_DISABLE 379
|
||||
#define K_SYSCALL_MDIO_BUS_ENABLE 380
|
||||
#define K_SYSCALL_MDIO_READ 381
|
||||
#define K_SYSCALL_MDIO_READ_C45 382
|
||||
#define K_SYSCALL_MDIO_WRITE 383
|
||||
#define K_SYSCALL_MDIO_WRITE_C45 384
|
||||
#define K_SYSCALL_MSPI_CONFIG 385
|
||||
#define K_SYSCALL_MSPI_DEV_CONFIG 386
|
||||
#define K_SYSCALL_MSPI_GET_CHANNEL_STATUS 387
|
||||
#define K_SYSCALL_MSPI_SCRAMBLE_CONFIG 388
|
||||
#define K_SYSCALL_MSPI_TIMING_CONFIG 389
|
||||
#define K_SYSCALL_MSPI_TRANSCEIVE 390
|
||||
#define K_SYSCALL_MSPI_XIP_CONFIG 391
|
||||
#define K_SYSCALL_NET_ADDR_NTOP 392
|
||||
#define K_SYSCALL_NET_ADDR_PTON 393
|
||||
#define K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX 394
|
||||
#define K_SYSCALL_NET_IF_GET_BY_INDEX 395
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_ADD_BY_INDEX 396
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_LOOKUP_BY_INDEX 397
|
||||
#define K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX 398
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_GW_BY_INDEX 399
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_ADDR_BY_INDEX 400
|
||||
#define K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_INDEX 401
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_ADD_BY_INDEX 402
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_LOOKUP_BY_INDEX 403
|
||||
#define K_SYSCALL_NET_IF_IPV6_ADDR_RM_BY_INDEX 404
|
||||
#define K_SYSCALL_NET_SOCKET_SERVICE_REGISTER 405
|
||||
#define K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE 406
|
||||
#define K_SYSCALL_OPAMP_SET_GAIN 407
|
||||
#define K_SYSCALL_PECI_CONFIG 408
|
||||
#define K_SYSCALL_PECI_DISABLE 409
|
||||
#define K_SYSCALL_PECI_ENABLE 410
|
||||
#define K_SYSCALL_PECI_TRANSFER 411
|
||||
#define K_SYSCALL_PS2_CONFIG 412
|
||||
#define K_SYSCALL_PS2_DISABLE_CALLBACK 413
|
||||
#define K_SYSCALL_PS2_ENABLE_CALLBACK 414
|
||||
#define K_SYSCALL_PS2_READ 415
|
||||
#define K_SYSCALL_PS2_WRITE 416
|
||||
#define K_SYSCALL_PSI5_REGISTER_CALLBACK 417
|
||||
#define K_SYSCALL_PSI5_SEND 418
|
||||
#define K_SYSCALL_PSI5_START_SYNC 419
|
||||
#define K_SYSCALL_PSI5_STOP_SYNC 420
|
||||
#define K_SYSCALL_PTP_CLOCK_GET 421
|
||||
#define K_SYSCALL_PWM_CAPTURE_CYCLES 422
|
||||
#define K_SYSCALL_PWM_DISABLE_CAPTURE 423
|
||||
#define K_SYSCALL_PWM_ENABLE_CAPTURE 424
|
||||
#define K_SYSCALL_PWM_GET_CYCLES_PER_SEC 425
|
||||
#define K_SYSCALL_PWM_SET_CYCLES 426
|
||||
#define K_SYSCALL_RENESAS_ELC_DISABLE 427
|
||||
#define K_SYSCALL_RENESAS_ELC_ENABLE 428
|
||||
#define K_SYSCALL_RENESAS_ELC_LINK_BREAK 429
|
||||
#define K_SYSCALL_RENESAS_ELC_LINK_SET 430
|
||||
#define K_SYSCALL_RENESAS_ELC_SOFTWARE_EVENT_GENERATE 431
|
||||
#define K_SYSCALL_RENESAS_RA_CTSU_GROUP_CONFIGURE 432
|
||||
#define K_SYSCALL_RENESAS_RX_CTSU_GROUP_CONFIGURE 433
|
||||
#define K_SYSCALL_RETAINED_MEM_CLEAR 434
|
||||
#define K_SYSCALL_RETAINED_MEM_READ 435
|
||||
#define K_SYSCALL_RETAINED_MEM_SIZE 436
|
||||
#define K_SYSCALL_RETAINED_MEM_WRITE 437
|
||||
#define K_SYSCALL_RTC_ALARM_GET_SUPPORTED_FIELDS 438
|
||||
#define K_SYSCALL_RTC_ALARM_GET_TIME 439
|
||||
#define K_SYSCALL_RTC_ALARM_IS_PENDING 440
|
||||
#define K_SYSCALL_RTC_ALARM_SET_TIME 441
|
||||
#define K_SYSCALL_RTC_GET_CALIBRATION 442
|
||||
#define K_SYSCALL_RTC_GET_TIME 443
|
||||
#define K_SYSCALL_RTC_SET_CALIBRATION 444
|
||||
#define K_SYSCALL_RTC_SET_TIME 445
|
||||
#define K_SYSCALL_RTIO_CQE_COPY_OUT 446
|
||||
#define K_SYSCALL_RTIO_CQE_GET_MEMPOOL_BUFFER 447
|
||||
#define K_SYSCALL_RTIO_POOL_ACQUIRE 448
|
||||
#define K_SYSCALL_RTIO_POOL_RELEASE 449
|
||||
#define K_SYSCALL_RTIO_RELEASE_BUFFER 450
|
||||
#define K_SYSCALL_RTIO_SQE_CANCEL 451
|
||||
#define K_SYSCALL_RTIO_SQE_COPY_IN_GET_HANDLES 452
|
||||
#define K_SYSCALL_RTIO_SQE_SIGNAL 453
|
||||
#define K_SYSCALL_RTIO_SUBMIT 454
|
||||
#define K_SYSCALL_SDHC_CARD_BUSY 455
|
||||
#define K_SYSCALL_SDHC_CARD_PRESENT 456
|
||||
#define K_SYSCALL_SDHC_DISABLE_INTERRUPT 457
|
||||
#define K_SYSCALL_SDHC_ENABLE_INTERRUPT 458
|
||||
#define K_SYSCALL_SDHC_EXECUTE_TUNING 459
|
||||
#define K_SYSCALL_SDHC_GET_HOST_PROPS 460
|
||||
#define K_SYSCALL_SDHC_HW_RESET 461
|
||||
#define K_SYSCALL_SDHC_REQUEST 462
|
||||
#define K_SYSCALL_SDHC_SET_IO 463
|
||||
#define K_SYSCALL_SENSOR_ATTR_GET 464
|
||||
#define K_SYSCALL_SENSOR_ATTR_SET 465
|
||||
#define K_SYSCALL_SENSOR_CHANNEL_GET 466
|
||||
#define K_SYSCALL_SENSOR_GET_DECODER 467
|
||||
#define K_SYSCALL_SENSOR_RECONFIGURE_READ_IODEV 468
|
||||
#define K_SYSCALL_SENSOR_SAMPLE_FETCH 469
|
||||
#define K_SYSCALL_SENSOR_SAMPLE_FETCH_CHAN 470
|
||||
#define K_SYSCALL_SENT_REGISTER_CALLBACK 471
|
||||
#define K_SYSCALL_SENT_START_LISTENING 472
|
||||
#define K_SYSCALL_SENT_STOP_LISTENING 473
|
||||
#define K_SYSCALL_SIP_SUPERVISORY_CALL 474
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_REQ 475
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_RES 476
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FORMAT_TRANS_ID 477
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FREE_ASYNC_MEMORY 478
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_FUNC_ID_VALID 479
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_GET_ERROR_CODE 480
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_GET_TRANS_IDX 481
|
||||
#define K_SYSCALL_SIP_SVC_PLAT_UPDATE_TRANS_ID 482
|
||||
#define K_SYSCALL_SMBUS_BLOCK_PCALL 483
|
||||
#define K_SYSCALL_SMBUS_BLOCK_READ 484
|
||||
#define K_SYSCALL_SMBUS_BLOCK_WRITE 485
|
||||
#define K_SYSCALL_SMBUS_BYTE_DATA_READ 486
|
||||
#define K_SYSCALL_SMBUS_BYTE_DATA_WRITE 487
|
||||
#define K_SYSCALL_SMBUS_BYTE_READ 488
|
||||
#define K_SYSCALL_SMBUS_BYTE_WRITE 489
|
||||
#define K_SYSCALL_SMBUS_CONFIGURE 490
|
||||
#define K_SYSCALL_SMBUS_GET_CONFIG 491
|
||||
#define K_SYSCALL_SMBUS_HOST_NOTIFY_REMOVE_CB 492
|
||||
#define K_SYSCALL_SMBUS_PCALL 493
|
||||
#define K_SYSCALL_SMBUS_QUICK 494
|
||||
#define K_SYSCALL_SMBUS_SMBALERT_REMOVE_CB 495
|
||||
#define K_SYSCALL_SMBUS_WORD_DATA_READ 496
|
||||
#define K_SYSCALL_SMBUS_WORD_DATA_WRITE 497
|
||||
#define K_SYSCALL_SPI_RELEASE 498
|
||||
#define K_SYSCALL_SPI_TRANSCEIVE 499
|
||||
#define K_SYSCALL_STEPPER_DISABLE 500
|
||||
#define K_SYSCALL_STEPPER_ENABLE 501
|
||||
#define K_SYSCALL_STEPPER_GET_ACTUAL_POSITION 502
|
||||
#define K_SYSCALL_STEPPER_GET_MICRO_STEP_RES 503
|
||||
#define K_SYSCALL_STEPPER_IS_MOVING 504
|
||||
#define K_SYSCALL_STEPPER_MOVE_BY 505
|
||||
#define K_SYSCALL_STEPPER_MOVE_TO 506
|
||||
#define K_SYSCALL_STEPPER_RUN 507
|
||||
#define K_SYSCALL_STEPPER_SET_EVENT_CALLBACK 508
|
||||
#define K_SYSCALL_STEPPER_SET_MICROSTEP_INTERVAL 509
|
||||
#define K_SYSCALL_STEPPER_SET_MICRO_STEP_RES 510
|
||||
#define K_SYSCALL_STEPPER_SET_REFERENCE_POSITION 511
|
||||
#define K_SYSCALL_STEPPER_STOP 512
|
||||
#define K_SYSCALL_SYSCON_GET_BASE 513
|
||||
#define K_SYSCALL_SYSCON_GET_SIZE 514
|
||||
#define K_SYSCALL_SYSCON_READ_REG 515
|
||||
#define K_SYSCALL_SYSCON_WRITE_REG 516
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE 517
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE 518
|
||||
#define K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE 519
|
||||
#define K_SYSCALL_SYS_CSRAND_GET 520
|
||||
#define K_SYSCALL_SYS_RAND_GET 521
|
||||
#define K_SYSCALL_TEE_CANCEL 522
|
||||
#define K_SYSCALL_TEE_CLOSE_SESSION 523
|
||||
#define K_SYSCALL_TEE_GET_VERSION 524
|
||||
#define K_SYSCALL_TEE_INVOKE_FUNC 525
|
||||
#define K_SYSCALL_TEE_OPEN_SESSION 526
|
||||
#define K_SYSCALL_TEE_SHM_ALLOC 527
|
||||
#define K_SYSCALL_TEE_SHM_FREE 528
|
||||
#define K_SYSCALL_TEE_SHM_REGISTER 529
|
||||
#define K_SYSCALL_TEE_SHM_UNREGISTER 530
|
||||
#define K_SYSCALL_TEE_SUPPL_RECV 531
|
||||
#define K_SYSCALL_TEE_SUPPL_SEND 532
|
||||
#define K_SYSCALL_TGPIO_PIN_CONFIG_EXT_TIMESTAMP 533
|
||||
#define K_SYSCALL_TGPIO_PIN_DISABLE 534
|
||||
#define K_SYSCALL_TGPIO_PIN_PERIODIC_OUTPUT 535
|
||||
#define K_SYSCALL_TGPIO_PIN_READ_TS_EC 536
|
||||
#define K_SYSCALL_TGPIO_PORT_GET_CYCLES_PER_SECOND 537
|
||||
#define K_SYSCALL_TGPIO_PORT_GET_TIME 538
|
||||
#define K_SYSCALL_UPDATEHUB_AUTOHANDLER 539
|
||||
#define K_SYSCALL_UPDATEHUB_CONFIRM 540
|
||||
#define K_SYSCALL_UPDATEHUB_PROBE 541
|
||||
#define K_SYSCALL_UPDATEHUB_REBOOT 542
|
||||
#define K_SYSCALL_UPDATEHUB_REPORT_ERROR 543
|
||||
#define K_SYSCALL_UPDATEHUB_UPDATE 544
|
||||
#define K_SYSCALL_USER_FAULT 545
|
||||
#define K_SYSCALL_W1_CHANGE_BUS_LOCK 546
|
||||
#define K_SYSCALL_W1_CONFIGURE 547
|
||||
#define K_SYSCALL_W1_GET_SLAVE_COUNT 548
|
||||
#define K_SYSCALL_W1_READ_BIT 549
|
||||
#define K_SYSCALL_W1_READ_BLOCK 550
|
||||
#define K_SYSCALL_W1_READ_BYTE 551
|
||||
#define K_SYSCALL_W1_RESET_BUS 552
|
||||
#define K_SYSCALL_W1_SEARCH_BUS 553
|
||||
#define K_SYSCALL_W1_WRITE_BIT 554
|
||||
#define K_SYSCALL_W1_WRITE_BLOCK 555
|
||||
#define K_SYSCALL_W1_WRITE_BYTE 556
|
||||
#define K_SYSCALL_WDT_DISABLE 557
|
||||
#define K_SYSCALL_WDT_FEED 558
|
||||
#define K_SYSCALL_WDT_SETUP 559
|
||||
#define K_SYSCALL_XTENSA_USER_FAULT 560
|
||||
#define K_SYSCALL_ZSOCK_ACCEPT 561
|
||||
#define K_SYSCALL_ZSOCK_BIND 562
|
||||
#define K_SYSCALL_ZSOCK_CLOSE 563
|
||||
#define K_SYSCALL_ZSOCK_CONNECT 564
|
||||
#define K_SYSCALL_ZSOCK_FCNTL_IMPL 565
|
||||
#define K_SYSCALL_ZSOCK_GETHOSTNAME 566
|
||||
#define K_SYSCALL_ZSOCK_GETPEERNAME 567
|
||||
#define K_SYSCALL_ZSOCK_GETSOCKNAME 568
|
||||
#define K_SYSCALL_ZSOCK_GETSOCKOPT 569
|
||||
#define K_SYSCALL_ZSOCK_GET_CONTEXT_OBJECT 570
|
||||
#define K_SYSCALL_ZSOCK_INET_PTON 571
|
||||
#define K_SYSCALL_ZSOCK_IOCTL_IMPL 572
|
||||
#define K_SYSCALL_ZSOCK_LISTEN 573
|
||||
#define K_SYSCALL_ZSOCK_RECVFROM 574
|
||||
#define K_SYSCALL_ZSOCK_RECVMSG 575
|
||||
#define K_SYSCALL_ZSOCK_SENDMSG 576
|
||||
#define K_SYSCALL_ZSOCK_SENDTO 577
|
||||
#define K_SYSCALL_ZSOCK_SETSOCKOPT 578
|
||||
#define K_SYSCALL_ZSOCK_SHUTDOWN 579
|
||||
#define K_SYSCALL_ZSOCK_SOCKET 580
|
||||
#define K_SYSCALL_ZSOCK_SOCKETPAIR 581
|
||||
#define K_SYSCALL_ZVFS_POLL 582
|
||||
#define K_SYSCALL_ZVFS_SELECT 583
|
||||
#define K_SYSCALL_Z_ERRNO 584
|
||||
#define K_SYSCALL_Z_ZSOCK_GETADDRINFO_INTERNAL 585
|
||||
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#endif /* _ASMLANGUAGE */
|
||||
|
||||
#endif /* ZEPHYR_SYSCALL_LIST_H */
|
||||
@@ -0,0 +1,125 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ADC_H
|
||||
#define Z_INCLUDE_SYSCALLS_ADC_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_adc_channel_setup(const struct device * dev, const struct adc_channel_cfg * channel_cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int adc_channel_setup(const struct device * dev, const struct adc_channel_cfg * channel_cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct adc_channel_cfg * val; } parm1 = { .val = channel_cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ADC_CHANNEL_SETUP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_adc_channel_setup(dev, channel_cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define adc_channel_setup(dev, channel_cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ADC_CHANNEL_SETUP, adc_channel_setup, dev, channel_cfg); syscall__retval = adc_channel_setup(dev, channel_cfg); sys_port_trace_syscall_exit(K_SYSCALL_ADC_CHANNEL_SETUP, adc_channel_setup, dev, channel_cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_adc_read(const struct device * dev, const struct adc_sequence * sequence);
|
||||
|
||||
__pinned_func
|
||||
static inline int adc_read(const struct device * dev, const struct adc_sequence * sequence)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct adc_sequence * val; } parm1 = { .val = sequence };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ADC_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_adc_read(dev, sequence);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define adc_read(dev, sequence) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ADC_READ, adc_read, dev, sequence); syscall__retval = adc_read(dev, sequence); sys_port_trace_syscall_exit(K_SYSCALL_ADC_READ, adc_read, dev, sequence, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_adc_read_async(const struct device * dev, const struct adc_sequence * sequence, struct k_poll_signal * async);
|
||||
|
||||
__pinned_func
|
||||
static inline int adc_read_async(const struct device * dev, const struct adc_sequence * sequence, struct k_poll_signal * async)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct adc_sequence * val; } parm1 = { .val = sequence };
|
||||
union { uintptr_t x; struct k_poll_signal * val; } parm2 = { .val = async };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ADC_READ_ASYNC);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_adc_read_async(dev, sequence, async);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define adc_read_async(dev, sequence, async) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ADC_READ_ASYNC, adc_read_async, dev, sequence, async); syscall__retval = adc_read_async(dev, sequence, async); sys_port_trace_syscall_exit(K_SYSCALL_ADC_READ_ASYNC, adc_read_async, dev, sequence, async, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_adc_get_decoder(const struct device * dev, const struct adc_decoder_api ** api);
|
||||
|
||||
__pinned_func
|
||||
static inline int adc_get_decoder(const struct device * dev, const struct adc_decoder_api ** api)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct adc_decoder_api ** val; } parm1 = { .val = api };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ADC_GET_DECODER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_adc_get_decoder(dev, api);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define adc_get_decoder(dev, api) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ADC_GET_DECODER, adc_get_decoder, dev, api); syscall__retval = adc_get_decoder(dev, api); sys_port_trace_syscall_exit(K_SYSCALL_ADC_GET_DECODER, adc_get_decoder, dev, api, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,52 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ARCH_H
|
||||
#define Z_INCLUDE_SYSCALLS_ARCH_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_xtensa_user_fault(unsigned int reason);
|
||||
|
||||
__pinned_func
|
||||
static inline void xtensa_user_fault(unsigned int reason)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; unsigned int val; } parm0 = { .val = reason };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_XTENSA_USER_FAULT);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_xtensa_user_fault(reason);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define xtensa_user_fault(reason) do { sys_port_trace_syscall_enter(K_SYSCALL_XTENSA_USER_FAULT, xtensa_user_fault, reason); xtensa_user_fault(reason); sys_port_trace_syscall_exit(K_SYSCALL_XTENSA_USER_FAULT, xtensa_user_fault, reason); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,270 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ATOMIC_C_H
|
||||
#define Z_INCLUDE_SYSCALLS_ATOMIC_C_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern bool z_impl_atomic_cas(atomic_t * target, atomic_val_t old_value, atomic_val_t new_value);
|
||||
|
||||
__pinned_func
|
||||
static inline bool atomic_cas(atomic_t * target, atomic_val_t old_value, atomic_val_t new_value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = old_value };
|
||||
union { uintptr_t x; atomic_val_t val; } parm2 = { .val = new_value };
|
||||
return (bool) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ATOMIC_CAS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_cas(target, old_value, new_value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_cas(target, old_value, new_value) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_CAS, atomic_cas, target, old_value, new_value); syscall__retval = atomic_cas(target, old_value, new_value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_CAS, atomic_cas, target, old_value, new_value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_atomic_ptr_cas(atomic_ptr_t * target, atomic_ptr_val_t old_value, atomic_ptr_val_t new_value);
|
||||
|
||||
__pinned_func
|
||||
static inline bool atomic_ptr_cas(atomic_ptr_t * target, atomic_ptr_val_t old_value, atomic_ptr_val_t new_value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_ptr_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_ptr_val_t val; } parm1 = { .val = old_value };
|
||||
union { uintptr_t x; atomic_ptr_val_t val; } parm2 = { .val = new_value };
|
||||
return (bool) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ATOMIC_PTR_CAS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_ptr_cas(target, old_value, new_value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_ptr_cas(target, old_value, new_value) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_PTR_CAS, atomic_ptr_cas, target, old_value, new_value); syscall__retval = atomic_ptr_cas(target, old_value, new_value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_PTR_CAS, atomic_ptr_cas, target, old_value, new_value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_val_t z_impl_atomic_add(atomic_t * target, atomic_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_val_t atomic_add(atomic_t * target, atomic_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_ADD);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_add(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_add(target, value) ({ atomic_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_ADD, atomic_add, target, value); syscall__retval = atomic_add(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_ADD, atomic_add, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_val_t z_impl_atomic_sub(atomic_t * target, atomic_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_val_t atomic_sub(atomic_t * target, atomic_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_SUB);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_sub(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_sub(target, value) ({ atomic_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_SUB, atomic_sub, target, value); syscall__retval = atomic_sub(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_SUB, atomic_sub, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_val_t z_impl_atomic_set(atomic_t * target, atomic_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_val_t atomic_set(atomic_t * target, atomic_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_set(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_set(target, value) ({ atomic_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_SET, atomic_set, target, value); syscall__retval = atomic_set(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_SET, atomic_set, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_ptr_val_t z_impl_atomic_ptr_set(atomic_ptr_t * target, atomic_ptr_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_ptr_val_t atomic_ptr_set(atomic_ptr_t * target, atomic_ptr_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_ptr_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_ptr_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_ptr_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_PTR_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_ptr_set(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_ptr_set(target, value) ({ atomic_ptr_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_PTR_SET, atomic_ptr_set, target, value); syscall__retval = atomic_ptr_set(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_PTR_SET, atomic_ptr_set, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_val_t z_impl_atomic_or(atomic_t * target, atomic_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_val_t atomic_or(atomic_t * target, atomic_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_OR);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_or(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_or(target, value) ({ atomic_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_OR, atomic_or, target, value); syscall__retval = atomic_or(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_OR, atomic_or, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_val_t z_impl_atomic_xor(atomic_t * target, atomic_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_val_t atomic_xor(atomic_t * target, atomic_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_XOR);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_xor(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_xor(target, value) ({ atomic_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_XOR, atomic_xor, target, value); syscall__retval = atomic_xor(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_XOR, atomic_xor, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_val_t z_impl_atomic_and(atomic_t * target, atomic_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_val_t atomic_and(atomic_t * target, atomic_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_AND);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_and(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_and(target, value) ({ atomic_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_AND, atomic_and, target, value); syscall__retval = atomic_and(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_AND, atomic_and, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern atomic_val_t z_impl_atomic_nand(atomic_t * target, atomic_val_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline atomic_val_t atomic_nand(atomic_t * target, atomic_val_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
|
||||
return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_NAND);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_atomic_nand(target, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define atomic_nand(target, value) ({ atomic_val_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_NAND, atomic_nand, target, value); syscall__retval = atomic_nand(target, value); sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_NAND, atomic_nand, target, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,488 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_AUXDISPLAY_H
|
||||
#define Z_INCLUDE_SYSCALLS_AUXDISPLAY_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_auxdisplay_display_on(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_display_on(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_AUXDISPLAY_DISPLAY_ON);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_display_on(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_display_on(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_DISPLAY_ON, auxdisplay_display_on, dev); syscall__retval = auxdisplay_display_on(dev); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_DISPLAY_ON, auxdisplay_display_on, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_display_off(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_display_off(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_AUXDISPLAY_DISPLAY_OFF);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_display_off(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_display_off(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_DISPLAY_OFF, auxdisplay_display_off, dev); syscall__retval = auxdisplay_display_off(dev); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_DISPLAY_OFF, auxdisplay_display_off, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_cursor_set_enabled(const struct device * dev, bool enabled);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_cursor_set_enabled(const struct device * dev, bool enabled)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; bool val; } parm1 = { .val = enabled };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_cursor_set_enabled(dev, enabled);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_cursor_set_enabled(dev, enabled) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED, auxdisplay_cursor_set_enabled, dev, enabled); syscall__retval = auxdisplay_cursor_set_enabled(dev, enabled); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED, auxdisplay_cursor_set_enabled, dev, enabled, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_position_blinking_set_enabled(const struct device * dev, bool enabled);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_position_blinking_set_enabled(const struct device * dev, bool enabled)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; bool val; } parm1 = { .val = enabled };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_position_blinking_set_enabled(dev, enabled);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_position_blinking_set_enabled(dev, enabled) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED, auxdisplay_position_blinking_set_enabled, dev, enabled); syscall__retval = auxdisplay_position_blinking_set_enabled(dev, enabled); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED, auxdisplay_position_blinking_set_enabled, dev, enabled, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_cursor_shift_set(const struct device * dev, uint8_t direction, bool display_shift);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_cursor_shift_set(const struct device * dev, uint8_t direction, bool display_shift)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = direction };
|
||||
union { uintptr_t x; bool val; } parm2 = { .val = display_shift };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_cursor_shift_set(dev, direction, display_shift);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_cursor_shift_set(dev, direction, display_shift) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET, auxdisplay_cursor_shift_set, dev, direction, display_shift); syscall__retval = auxdisplay_cursor_shift_set(dev, direction, display_shift); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET, auxdisplay_cursor_shift_set, dev, direction, display_shift, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_cursor_position_set(const struct device * dev, enum auxdisplay_position type, int16_t x, int16_t y);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_cursor_position_set(const struct device * dev, enum auxdisplay_position type, int16_t x, int16_t y)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum auxdisplay_position val; } parm1 = { .val = type };
|
||||
union { uintptr_t x; int16_t val; } parm2 = { .val = x };
|
||||
union { uintptr_t x; int16_t val; } parm3 = { .val = y };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_cursor_position_set(dev, type, x, y);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_cursor_position_set(dev, type, x, y) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET, auxdisplay_cursor_position_set, dev, type, x, y); syscall__retval = auxdisplay_cursor_position_set(dev, type, x, y); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET, auxdisplay_cursor_position_set, dev, type, x, y, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_cursor_position_get(const struct device * dev, int16_t * x, int16_t * y);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_cursor_position_get(const struct device * dev, int16_t * x, int16_t * y)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; int16_t * val; } parm1 = { .val = x };
|
||||
union { uintptr_t x; int16_t * val; } parm2 = { .val = y };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_cursor_position_get(dev, x, y);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_cursor_position_get(dev, x, y) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET, auxdisplay_cursor_position_get, dev, x, y); syscall__retval = auxdisplay_cursor_position_get(dev, x, y); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET, auxdisplay_cursor_position_get, dev, x, y, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_display_position_set(const struct device * dev, enum auxdisplay_position type, int16_t x, int16_t y);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_display_position_set(const struct device * dev, enum auxdisplay_position type, int16_t x, int16_t y)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum auxdisplay_position val; } parm1 = { .val = type };
|
||||
union { uintptr_t x; int16_t val; } parm2 = { .val = x };
|
||||
union { uintptr_t x; int16_t val; } parm3 = { .val = y };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_display_position_set(dev, type, x, y);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_display_position_set(dev, type, x, y) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET, auxdisplay_display_position_set, dev, type, x, y); syscall__retval = auxdisplay_display_position_set(dev, type, x, y); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET, auxdisplay_display_position_set, dev, type, x, y, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_display_position_get(const struct device * dev, int16_t * x, int16_t * y);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_display_position_get(const struct device * dev, int16_t * x, int16_t * y)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; int16_t * val; } parm1 = { .val = x };
|
||||
union { uintptr_t x; int16_t * val; } parm2 = { .val = y };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_display_position_get(dev, x, y);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_display_position_get(dev, x, y) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET, auxdisplay_display_position_get, dev, x, y); syscall__retval = auxdisplay_display_position_get(dev, x, y); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET, auxdisplay_display_position_get, dev, x, y, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_capabilities_get(const struct device * dev, struct auxdisplay_capabilities * capabilities);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_capabilities_get(const struct device * dev, struct auxdisplay_capabilities * capabilities)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct auxdisplay_capabilities * val; } parm1 = { .val = capabilities };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_capabilities_get(dev, capabilities);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_capabilities_get(dev, capabilities) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET, auxdisplay_capabilities_get, dev, capabilities); syscall__retval = auxdisplay_capabilities_get(dev, capabilities); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET, auxdisplay_capabilities_get, dev, capabilities, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_clear(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_clear(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_AUXDISPLAY_CLEAR);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_clear(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_clear(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CLEAR, auxdisplay_clear, dev); syscall__retval = auxdisplay_clear(dev); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CLEAR, auxdisplay_clear, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_brightness_get(const struct device * dev, uint8_t * brightness);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_brightness_get(const struct device * dev, uint8_t * brightness)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t * val; } parm1 = { .val = brightness };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_brightness_get(dev, brightness);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_brightness_get(dev, brightness) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET, auxdisplay_brightness_get, dev, brightness); syscall__retval = auxdisplay_brightness_get(dev, brightness); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET, auxdisplay_brightness_get, dev, brightness, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_brightness_set(const struct device * dev, uint8_t brightness);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_brightness_set(const struct device * dev, uint8_t brightness)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = brightness };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_brightness_set(dev, brightness);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_brightness_set(dev, brightness) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET, auxdisplay_brightness_set, dev, brightness); syscall__retval = auxdisplay_brightness_set(dev, brightness); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET, auxdisplay_brightness_set, dev, brightness, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_backlight_get(const struct device * dev, uint8_t * backlight);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_backlight_get(const struct device * dev, uint8_t * backlight)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t * val; } parm1 = { .val = backlight };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_backlight_get(dev, backlight);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_backlight_get(dev, backlight) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET, auxdisplay_backlight_get, dev, backlight); syscall__retval = auxdisplay_backlight_get(dev, backlight); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET, auxdisplay_backlight_get, dev, backlight, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_backlight_set(const struct device * dev, uint8_t backlight);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_backlight_set(const struct device * dev, uint8_t backlight)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = backlight };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_backlight_set(dev, backlight);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_backlight_set(dev, backlight) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET, auxdisplay_backlight_set, dev, backlight); syscall__retval = auxdisplay_backlight_set(dev, backlight); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET, auxdisplay_backlight_set, dev, backlight, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_is_busy(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_is_busy(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_AUXDISPLAY_IS_BUSY);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_is_busy(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_is_busy(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_IS_BUSY, auxdisplay_is_busy, dev); syscall__retval = auxdisplay_is_busy(dev); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_IS_BUSY, auxdisplay_is_busy, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_custom_character_set(const struct device * dev, struct auxdisplay_character * character);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_custom_character_set(const struct device * dev, struct auxdisplay_character * character)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct auxdisplay_character * val; } parm1 = { .val = character };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_custom_character_set(dev, character);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_custom_character_set(dev, character) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET, auxdisplay_custom_character_set, dev, character); syscall__retval = auxdisplay_custom_character_set(dev, character); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET, auxdisplay_custom_character_set, dev, character, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_write(const struct device * dev, const uint8_t * data, uint16_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_write(const struct device * dev, const uint8_t * data, uint16_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const uint8_t * val; } parm1 = { .val = data };
|
||||
union { uintptr_t x; uint16_t val; } parm2 = { .val = len };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_AUXDISPLAY_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_write(dev, data, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_write(dev, data, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_WRITE, auxdisplay_write, dev, data, len); syscall__retval = auxdisplay_write(dev, data, len); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_WRITE, auxdisplay_write, dev, data, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_auxdisplay_custom_command(const struct device * dev, struct auxdisplay_custom_data * data);
|
||||
|
||||
__pinned_func
|
||||
static inline int auxdisplay_custom_command(const struct device * dev, struct auxdisplay_custom_data * data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct auxdisplay_custom_data * val; } parm1 = { .val = data };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_auxdisplay_custom_command(dev, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define auxdisplay_custom_command(dev, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND, auxdisplay_custom_command, dev, data); syscall__retval = auxdisplay_custom_command(dev, data); sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND, auxdisplay_custom_command, dev, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,173 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_BBRAM_H
|
||||
#define Z_INCLUDE_SYSCALLS_BBRAM_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_bbram_check_invalid(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int bbram_check_invalid(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_BBRAM_CHECK_INVALID);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_bbram_check_invalid(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define bbram_check_invalid(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_CHECK_INVALID, bbram_check_invalid, dev); syscall__retval = bbram_check_invalid(dev); sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_CHECK_INVALID, bbram_check_invalid, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_bbram_check_standby_power(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int bbram_check_standby_power(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_BBRAM_CHECK_STANDBY_POWER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_bbram_check_standby_power(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define bbram_check_standby_power(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_CHECK_STANDBY_POWER, bbram_check_standby_power, dev); syscall__retval = bbram_check_standby_power(dev); sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_CHECK_STANDBY_POWER, bbram_check_standby_power, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_bbram_check_power(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int bbram_check_power(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_BBRAM_CHECK_POWER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_bbram_check_power(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define bbram_check_power(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_CHECK_POWER, bbram_check_power, dev); syscall__retval = bbram_check_power(dev); sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_CHECK_POWER, bbram_check_power, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_bbram_get_size(const struct device * dev, size_t * size);
|
||||
|
||||
__pinned_func
|
||||
static inline int bbram_get_size(const struct device * dev, size_t * size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; size_t * val; } parm1 = { .val = size };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_BBRAM_GET_SIZE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_bbram_get_size(dev, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define bbram_get_size(dev, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_GET_SIZE, bbram_get_size, dev, size); syscall__retval = bbram_get_size(dev, size); sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_GET_SIZE, bbram_get_size, dev, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_bbram_read(const struct device * dev, size_t offset, size_t size, uint8_t * data);
|
||||
|
||||
__pinned_func
|
||||
static inline int bbram_read(const struct device * dev, size_t offset, size_t size, uint8_t * data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = size };
|
||||
union { uintptr_t x; uint8_t * val; } parm3 = { .val = data };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_BBRAM_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_bbram_read(dev, offset, size, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define bbram_read(dev, offset, size, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_READ, bbram_read, dev, offset, size, data); syscall__retval = bbram_read(dev, offset, size, data); sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_READ, bbram_read, dev, offset, size, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_bbram_write(const struct device * dev, size_t offset, size_t size, const uint8_t * data);
|
||||
|
||||
__pinned_func
|
||||
static inline int bbram_write(const struct device * dev, size_t offset, size_t size, const uint8_t * data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = size };
|
||||
union { uintptr_t x; const uint8_t * val; } parm3 = { .val = data };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_BBRAM_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_bbram_write(dev, offset, size, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define bbram_write(dev, offset, size, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_WRITE, bbram_write, dev, offset, size, data); syscall__retval = bbram_write(dev, offset, size, data); sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_WRITE, bbram_write, dev, offset, size, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,100 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_CACHE_H
|
||||
#define Z_INCLUDE_SYSCALLS_CACHE_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_sys_cache_data_flush_range(void * addr, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int sys_cache_data_flush_range(void * addr, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; void * val; } parm0 = { .val = addr };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = size };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sys_cache_data_flush_range(addr, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sys_cache_data_flush_range(addr, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE, sys_cache_data_flush_range, addr, size); syscall__retval = sys_cache_data_flush_range(addr, size); sys_port_trace_syscall_exit(K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE, sys_cache_data_flush_range, addr, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sys_cache_data_invd_range(void * addr, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int sys_cache_data_invd_range(void * addr, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; void * val; } parm0 = { .val = addr };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = size };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sys_cache_data_invd_range(addr, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sys_cache_data_invd_range(addr, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE, sys_cache_data_invd_range, addr, size); syscall__retval = sys_cache_data_invd_range(addr, size); sys_port_trace_syscall_exit(K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE, sys_cache_data_invd_range, addr, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sys_cache_data_flush_and_invd_range(void * addr, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int sys_cache_data_flush_and_invd_range(void * addr, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; void * val; } parm0 = { .val = addr };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = size };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sys_cache_data_flush_and_invd_range(addr, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sys_cache_data_flush_and_invd_range(addr, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE, sys_cache_data_flush_and_invd_range, addr, size); syscall__retval = sys_cache_data_flush_and_invd_range(addr, size); sys_port_trace_syscall_exit(K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE, sys_cache_data_flush_and_invd_range, addr, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,812 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_CAN_H
|
||||
#define Z_INCLUDE_SYSCALLS_CAN_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_can_get_core_clock(const struct device * dev, uint32_t * rate);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_get_core_clock(const struct device * dev, uint32_t * rate)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t * val; } parm1 = { .val = rate };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_GET_CORE_CLOCK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_core_clock(dev, rate);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_core_clock(dev, rate) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_CORE_CLOCK, can_get_core_clock, dev, rate); syscall__retval = can_get_core_clock(dev, rate); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_CORE_CLOCK, can_get_core_clock, dev, rate, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_get_bitrate_min(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_get_bitrate_min(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_BITRATE_MIN);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_bitrate_min(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_bitrate_min(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_BITRATE_MIN, can_get_bitrate_min, dev); syscall__retval = can_get_bitrate_min(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_BITRATE_MIN, can_get_bitrate_min, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_get_bitrate_max(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_get_bitrate_max(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_BITRATE_MAX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_bitrate_max(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_bitrate_max(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_BITRATE_MAX, can_get_bitrate_max, dev); syscall__retval = can_get_bitrate_max(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_BITRATE_MAX, can_get_bitrate_max, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern const struct can_timing * z_impl_can_get_timing_min(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct can_timing * can_get_timing_min(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (const struct can_timing *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TIMING_MIN);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_timing_min(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_timing_min(dev) ({ const struct can_timing * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TIMING_MIN, can_get_timing_min, dev); syscall__retval = can_get_timing_min(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TIMING_MIN, can_get_timing_min, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern const struct can_timing * z_impl_can_get_timing_max(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct can_timing * can_get_timing_max(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (const struct can_timing *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TIMING_MAX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_timing_max(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_timing_max(dev) ({ const struct can_timing * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TIMING_MAX, can_get_timing_max, dev); syscall__retval = can_get_timing_max(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TIMING_MAX, can_get_timing_max, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_calc_timing(const struct device * dev, struct can_timing * res, uint32_t bitrate, uint16_t sample_pnt);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_calc_timing(const struct device * dev, struct can_timing * res, uint32_t bitrate, uint16_t sample_pnt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct can_timing * val; } parm1 = { .val = res };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = bitrate };
|
||||
union { uintptr_t x; uint16_t val; } parm3 = { .val = sample_pnt };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_CAN_CALC_TIMING);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_calc_timing(dev, res, bitrate, sample_pnt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_calc_timing(dev, res, bitrate, sample_pnt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_CALC_TIMING, can_calc_timing, dev, res, bitrate, sample_pnt); syscall__retval = can_calc_timing(dev, res, bitrate, sample_pnt); sys_port_trace_syscall_exit(K_SYSCALL_CAN_CALC_TIMING, can_calc_timing, dev, res, bitrate, sample_pnt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern const struct can_timing * z_impl_can_get_timing_data_min(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct can_timing * can_get_timing_data_min(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (const struct can_timing *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TIMING_DATA_MIN);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_timing_data_min(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_timing_data_min(dev) ({ const struct can_timing * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TIMING_DATA_MIN, can_get_timing_data_min, dev); syscall__retval = can_get_timing_data_min(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TIMING_DATA_MIN, can_get_timing_data_min, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern const struct can_timing * z_impl_can_get_timing_data_max(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct can_timing * can_get_timing_data_max(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (const struct can_timing *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TIMING_DATA_MAX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_timing_data_max(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_timing_data_max(dev) ({ const struct can_timing * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TIMING_DATA_MAX, can_get_timing_data_max, dev); syscall__retval = can_get_timing_data_max(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TIMING_DATA_MAX, can_get_timing_data_max, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_calc_timing_data(const struct device * dev, struct can_timing * res, uint32_t bitrate, uint16_t sample_pnt);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_calc_timing_data(const struct device * dev, struct can_timing * res, uint32_t bitrate, uint16_t sample_pnt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct can_timing * val; } parm1 = { .val = res };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = bitrate };
|
||||
union { uintptr_t x; uint16_t val; } parm3 = { .val = sample_pnt };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_CAN_CALC_TIMING_DATA);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_calc_timing_data(dev, res, bitrate, sample_pnt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_calc_timing_data(dev, res, bitrate, sample_pnt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_CALC_TIMING_DATA, can_calc_timing_data, dev, res, bitrate, sample_pnt); syscall__retval = can_calc_timing_data(dev, res, bitrate, sample_pnt); sys_port_trace_syscall_exit(K_SYSCALL_CAN_CALC_TIMING_DATA, can_calc_timing_data, dev, res, bitrate, sample_pnt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_set_timing_data(const struct device * dev, const struct can_timing * timing_data);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_set_timing_data(const struct device * dev, const struct can_timing * timing_data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct can_timing * val; } parm1 = { .val = timing_data };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_TIMING_DATA);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_set_timing_data(dev, timing_data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_set_timing_data(dev, timing_data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_TIMING_DATA, can_set_timing_data, dev, timing_data); syscall__retval = can_set_timing_data(dev, timing_data); sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_TIMING_DATA, can_set_timing_data, dev, timing_data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_set_bitrate_data(const struct device * dev, uint32_t bitrate_data);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_set_bitrate_data(const struct device * dev, uint32_t bitrate_data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = bitrate_data };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_BITRATE_DATA);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_set_bitrate_data(dev, bitrate_data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_set_bitrate_data(dev, bitrate_data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_BITRATE_DATA, can_set_bitrate_data, dev, bitrate_data); syscall__retval = can_set_bitrate_data(dev, bitrate_data); sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_BITRATE_DATA, can_set_bitrate_data, dev, bitrate_data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_set_timing(const struct device * dev, const struct can_timing * timing);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_set_timing(const struct device * dev, const struct can_timing * timing)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct can_timing * val; } parm1 = { .val = timing };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_TIMING);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_set_timing(dev, timing);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_set_timing(dev, timing) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_TIMING, can_set_timing, dev, timing); syscall__retval = can_set_timing(dev, timing); sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_TIMING, can_set_timing, dev, timing, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_get_capabilities(const struct device * dev, can_mode_t * cap);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_get_capabilities(const struct device * dev, can_mode_t * cap)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; can_mode_t * val; } parm1 = { .val = cap };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_GET_CAPABILITIES);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_capabilities(dev, cap);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_capabilities(dev, cap) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_CAPABILITIES, can_get_capabilities, dev, cap); syscall__retval = can_get_capabilities(dev, cap); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_CAPABILITIES, can_get_capabilities, dev, cap, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern const struct device * z_impl_can_get_transceiver(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct device * can_get_transceiver(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (const struct device *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TRANSCEIVER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_transceiver(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_transceiver(dev) ({ const struct device * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TRANSCEIVER, can_get_transceiver, dev); syscall__retval = can_get_transceiver(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TRANSCEIVER, can_get_transceiver, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_start(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_start(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_START);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_start(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_start(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_START, can_start, dev); syscall__retval = can_start(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_START, can_start, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_stop(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_stop(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STOP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stop(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stop(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STOP, can_stop, dev); syscall__retval = can_stop(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STOP, can_stop, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_set_mode(const struct device * dev, can_mode_t mode);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_set_mode(const struct device * dev, can_mode_t mode)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; can_mode_t val; } parm1 = { .val = mode };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_MODE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_set_mode(dev, mode);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_set_mode(dev, mode) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_MODE, can_set_mode, dev, mode); syscall__retval = can_set_mode(dev, mode); sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_MODE, can_set_mode, dev, mode, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern can_mode_t z_impl_can_get_mode(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline can_mode_t can_get_mode(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (can_mode_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_MODE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_mode(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_mode(dev) ({ can_mode_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_MODE, can_get_mode, dev); syscall__retval = can_get_mode(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_MODE, can_get_mode, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_set_bitrate(const struct device * dev, uint32_t bitrate);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_set_bitrate(const struct device * dev, uint32_t bitrate)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = bitrate };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_BITRATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_set_bitrate(dev, bitrate);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_set_bitrate(dev, bitrate) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_BITRATE, can_set_bitrate, dev, bitrate); syscall__retval = can_set_bitrate(dev, bitrate); sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_BITRATE, can_set_bitrate, dev, bitrate, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_send(const struct device * dev, const struct can_frame * frame, k_timeout_t timeout, can_tx_callback_t callback, void * user_data);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_send(const struct device * dev, const struct can_frame * frame, k_timeout_t timeout, can_tx_callback_t callback, void * user_data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct can_frame * val; } parm1 = { .val = frame };
|
||||
union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm2 = { .val = timeout };
|
||||
union { uintptr_t x; can_tx_callback_t val; } parm3 = { .val = callback };
|
||||
union { uintptr_t x; void * val; } parm4 = { .val = user_data };
|
||||
return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.split.lo, parm2.split.hi, parm3.x, parm4.x, K_SYSCALL_CAN_SEND);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_send(dev, frame, timeout, callback, user_data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_send(dev, frame, timeout, callback, user_data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_SEND, can_send, dev, frame, timeout, callback, user_data); syscall__retval = can_send(dev, frame, timeout, callback, user_data); sys_port_trace_syscall_exit(K_SYSCALL_CAN_SEND, can_send, dev, frame, timeout, callback, user_data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_add_rx_filter_msgq(const struct device * dev, struct k_msgq * msgq, const struct can_filter * filter);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_add_rx_filter_msgq(const struct device * dev, struct k_msgq * msgq, const struct can_filter * filter)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct k_msgq * val; } parm1 = { .val = msgq };
|
||||
union { uintptr_t x; const struct can_filter * val; } parm2 = { .val = filter };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_add_rx_filter_msgq(dev, msgq, filter);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_add_rx_filter_msgq(dev, msgq, filter) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ, can_add_rx_filter_msgq, dev, msgq, filter); syscall__retval = can_add_rx_filter_msgq(dev, msgq, filter); sys_port_trace_syscall_exit(K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ, can_add_rx_filter_msgq, dev, msgq, filter, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_can_remove_rx_filter(const struct device * dev, int filter_id);
|
||||
|
||||
__pinned_func
|
||||
static inline void can_remove_rx_filter(const struct device * dev, int filter_id)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; int val; } parm1 = { .val = filter_id };
|
||||
(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_REMOVE_RX_FILTER);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_can_remove_rx_filter(dev, filter_id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_remove_rx_filter(dev, filter_id) do { sys_port_trace_syscall_enter(K_SYSCALL_CAN_REMOVE_RX_FILTER, can_remove_rx_filter, dev, filter_id); can_remove_rx_filter(dev, filter_id); sys_port_trace_syscall_exit(K_SYSCALL_CAN_REMOVE_RX_FILTER, can_remove_rx_filter, dev, filter_id); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_get_max_filters(const struct device * dev, bool ide);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_get_max_filters(const struct device * dev, bool ide)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; bool val; } parm1 = { .val = ide };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_GET_MAX_FILTERS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_max_filters(dev, ide);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_max_filters(dev, ide) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_MAX_FILTERS, can_get_max_filters, dev, ide); syscall__retval = can_get_max_filters(dev, ide); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_MAX_FILTERS, can_get_max_filters, dev, ide, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_get_state(const struct device * dev, enum can_state * state, struct can_bus_err_cnt * err_cnt);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_get_state(const struct device * dev, enum can_state * state, struct can_bus_err_cnt * err_cnt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum can_state * val; } parm1 = { .val = state };
|
||||
union { uintptr_t x; struct can_bus_err_cnt * val; } parm2 = { .val = err_cnt };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_CAN_GET_STATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_get_state(dev, state, err_cnt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_get_state(dev, state, err_cnt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_STATE, can_get_state, dev, state, err_cnt); syscall__retval = can_get_state(dev, state, err_cnt); sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_STATE, can_get_state, dev, state, err_cnt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_can_recover(const struct device * dev, k_timeout_t timeout);
|
||||
|
||||
__pinned_func
|
||||
static inline int can_recover(const struct device * dev, k_timeout_t timeout)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm1 = { .val = timeout };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.split.lo, parm1.split.hi, K_SYSCALL_CAN_RECOVER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_recover(dev, timeout);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_recover(dev, timeout) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_RECOVER, can_recover, dev, timeout); syscall__retval = can_recover(dev, timeout); sys_port_trace_syscall_exit(K_SYSCALL_CAN_RECOVER, can_recover, dev, timeout, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_bit_errors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_bit_errors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_BIT_ERRORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_bit_errors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_bit_errors(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_BIT_ERRORS, can_stats_get_bit_errors, dev); syscall__retval = can_stats_get_bit_errors(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_BIT_ERRORS, can_stats_get_bit_errors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_bit0_errors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_bit0_errors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_bit0_errors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_bit0_errors(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS, can_stats_get_bit0_errors, dev); syscall__retval = can_stats_get_bit0_errors(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS, can_stats_get_bit0_errors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_bit1_errors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_bit1_errors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_bit1_errors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_bit1_errors(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS, can_stats_get_bit1_errors, dev); syscall__retval = can_stats_get_bit1_errors(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS, can_stats_get_bit1_errors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_stuff_errors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_stuff_errors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_stuff_errors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_stuff_errors(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS, can_stats_get_stuff_errors, dev); syscall__retval = can_stats_get_stuff_errors(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS, can_stats_get_stuff_errors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_crc_errors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_crc_errors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_CRC_ERRORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_crc_errors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_crc_errors(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_CRC_ERRORS, can_stats_get_crc_errors, dev); syscall__retval = can_stats_get_crc_errors(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_CRC_ERRORS, can_stats_get_crc_errors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_form_errors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_form_errors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_FORM_ERRORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_form_errors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_form_errors(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_FORM_ERRORS, can_stats_get_form_errors, dev); syscall__retval = can_stats_get_form_errors(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_FORM_ERRORS, can_stats_get_form_errors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_ack_errors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_ack_errors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_ACK_ERRORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_ack_errors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_ack_errors(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_ACK_ERRORS, can_stats_get_ack_errors, dev); syscall__retval = can_stats_get_ack_errors(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_ACK_ERRORS, can_stats_get_ack_errors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_can_stats_get_rx_overruns(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t can_stats_get_rx_overruns(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_can_stats_get_rx_overruns(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define can_stats_get_rx_overruns(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS, can_stats_get_rx_overruns, dev); syscall__retval = can_stats_get_rx_overruns(dev); sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS, can_stats_get_rx_overruns, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,102 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_CHARGER_H
|
||||
#define Z_INCLUDE_SYSCALLS_CHARGER_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_charger_get_prop(const struct device * dev, const charger_prop_t prop, union charger_propval * val);
|
||||
|
||||
__pinned_func
|
||||
static inline int charger_get_prop(const struct device * dev, const charger_prop_t prop, union charger_propval * val)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const charger_prop_t val; } parm1 = { .val = prop };
|
||||
union { uintptr_t x; union charger_propval * val; } parm2 = { .val = val };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_CHARGER_GET_PROP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_charger_get_prop(dev, prop, val);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define charger_get_prop(dev, prop, val) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CHARGER_GET_PROP, charger_get_prop, dev, prop, val); syscall__retval = charger_get_prop(dev, prop, val); sys_port_trace_syscall_exit(K_SYSCALL_CHARGER_GET_PROP, charger_get_prop, dev, prop, val, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_charger_set_prop(const struct device * dev, const charger_prop_t prop, const union charger_propval * val);
|
||||
|
||||
__pinned_func
|
||||
static inline int charger_set_prop(const struct device * dev, const charger_prop_t prop, const union charger_propval * val)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const charger_prop_t val; } parm1 = { .val = prop };
|
||||
union { uintptr_t x; const union charger_propval * val; } parm2 = { .val = val };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_CHARGER_SET_PROP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_charger_set_prop(dev, prop, val);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define charger_set_prop(dev, prop, val) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CHARGER_SET_PROP, charger_set_prop, dev, prop, val); syscall__retval = charger_set_prop(dev, prop, val); sys_port_trace_syscall_exit(K_SYSCALL_CHARGER_SET_PROP, charger_set_prop, dev, prop, val, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_charger_charge_enable(const struct device * dev, const bool enable);
|
||||
|
||||
__pinned_func
|
||||
static inline int charger_charge_enable(const struct device * dev, const bool enable)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const bool val; } parm1 = { .val = enable };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CHARGER_CHARGE_ENABLE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_charger_charge_enable(dev, enable);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define charger_charge_enable(dev, enable) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CHARGER_CHARGE_ENABLE, charger_charge_enable, dev, enable); syscall__retval = charger_charge_enable(dev, enable); sys_port_trace_syscall_exit(K_SYSCALL_CHARGER_CHARGE_ENABLE, charger_charge_enable, dev, enable, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,102 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_CLOCK_H
|
||||
#define Z_INCLUDE_SYSCALLS_CLOCK_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_sys_clock_getrtoffset(struct timespec * tp);
|
||||
|
||||
__pinned_func
|
||||
static inline void sys_clock_getrtoffset(struct timespec * tp)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct timespec * val; } parm0 = { .val = tp };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_SYS_CLOCK_GETRTOFFSET);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_sys_clock_getrtoffset(tp);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sys_clock_getrtoffset(tp) do { sys_port_trace_syscall_enter(K_SYSCALL_SYS_CLOCK_GETRTOFFSET, sys_clock_getrtoffset, tp); sys_clock_getrtoffset(tp); sys_port_trace_syscall_exit(K_SYSCALL_SYS_CLOCK_GETRTOFFSET, sys_clock_getrtoffset, tp); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sys_clock_settime(int clock_id, const struct timespec * tp);
|
||||
|
||||
__pinned_func
|
||||
static inline int sys_clock_settime(int clock_id, const struct timespec * tp)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = clock_id };
|
||||
union { uintptr_t x; const struct timespec * val; } parm1 = { .val = tp };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_CLOCK_SETTIME);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sys_clock_settime(clock_id, tp);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sys_clock_settime(clock_id, tp) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SYS_CLOCK_SETTIME, sys_clock_settime, clock_id, tp); syscall__retval = sys_clock_settime(clock_id, tp); sys_port_trace_syscall_exit(K_SYSCALL_SYS_CLOCK_SETTIME, sys_clock_settime, clock_id, tp, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sys_clock_nanosleep(int clock_id, int flags, const struct timespec * rqtp, struct timespec * rmtp);
|
||||
|
||||
__pinned_func
|
||||
static inline int sys_clock_nanosleep(int clock_id, int flags, const struct timespec * rqtp, struct timespec * rmtp)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = clock_id };
|
||||
union { uintptr_t x; int val; } parm1 = { .val = flags };
|
||||
union { uintptr_t x; const struct timespec * val; } parm2 = { .val = rqtp };
|
||||
union { uintptr_t x; struct timespec * val; } parm3 = { .val = rmtp };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_SYS_CLOCK_NANOSLEEP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sys_clock_nanosleep(clock_id, flags, rqtp, rmtp);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sys_clock_nanosleep(clock_id, flags, rqtp, rmtp) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SYS_CLOCK_NANOSLEEP, sys_clock_nanosleep, clock_id, flags, rqtp, rmtp); syscall__retval = sys_clock_nanosleep(clock_id, flags, rqtp, rmtp); sys_port_trace_syscall_exit(K_SYSCALL_SYS_CLOCK_NANOSLEEP, sys_clock_nanosleep, clock_id, flags, rqtp, rmtp, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,98 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_COMPARATOR_H
|
||||
#define Z_INCLUDE_SYSCALLS_COMPARATOR_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_comparator_get_output(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int comparator_get_output(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_COMPARATOR_GET_OUTPUT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_comparator_get_output(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define comparator_get_output(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COMPARATOR_GET_OUTPUT, comparator_get_output, dev); syscall__retval = comparator_get_output(dev); sys_port_trace_syscall_exit(K_SYSCALL_COMPARATOR_GET_OUTPUT, comparator_get_output, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_comparator_set_trigger(const struct device * dev, enum comparator_trigger trigger);
|
||||
|
||||
__pinned_func
|
||||
static inline int comparator_set_trigger(const struct device * dev, enum comparator_trigger trigger)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum comparator_trigger val; } parm1 = { .val = trigger };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COMPARATOR_SET_TRIGGER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_comparator_set_trigger(dev, trigger);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define comparator_set_trigger(dev, trigger) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COMPARATOR_SET_TRIGGER, comparator_set_trigger, dev, trigger); syscall__retval = comparator_set_trigger(dev, trigger); sys_port_trace_syscall_exit(K_SYSCALL_COMPARATOR_SET_TRIGGER, comparator_set_trigger, dev, trigger, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_comparator_trigger_is_pending(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int comparator_trigger_is_pending(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_COMPARATOR_TRIGGER_IS_PENDING);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_comparator_trigger_is_pending(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define comparator_trigger_is_pending(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COMPARATOR_TRIGGER_IS_PENDING, comparator_trigger_is_pending, dev); syscall__retval = comparator_trigger_is_pending(dev); sys_port_trace_syscall_exit(K_SYSCALL_COMPARATOR_TRIGGER_IS_PENDING, comparator_trigger_is_pending, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,481 @@
|
||||
/* 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 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_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_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 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_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_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_channel_alarm(const struct device * dev, uint8_t chan_id, const struct counter_alarm_cfg * alarm_cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_set_channel_alarm(const struct device * dev, uint8_t chan_id, const struct counter_alarm_cfg * alarm_cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = chan_id };
|
||||
union { uintptr_t x; const struct counter_alarm_cfg * val; } parm2 = { .val = alarm_cfg };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_COUNTER_SET_CHANNEL_ALARM);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_set_channel_alarm(dev, chan_id, alarm_cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_set_channel_alarm(dev, chan_id, alarm_cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_SET_CHANNEL_ALARM, counter_set_channel_alarm, dev, chan_id, alarm_cfg); syscall__retval = counter_set_channel_alarm(dev, chan_id, alarm_cfg); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_SET_CHANNEL_ALARM, counter_set_channel_alarm, dev, chan_id, alarm_cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_cancel_channel_alarm(const struct device * dev, uint8_t chan_id);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_cancel_channel_alarm(const struct device * dev, uint8_t chan_id)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = chan_id };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_cancel_channel_alarm(dev, chan_id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_cancel_channel_alarm(dev, chan_id) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM, counter_cancel_channel_alarm, dev, chan_id); syscall__retval = counter_cancel_channel_alarm(dev, chan_id); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM, counter_cancel_channel_alarm, dev, chan_id, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_set_top_value(const struct device * dev, const struct counter_top_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_set_top_value(const struct device * dev, const struct counter_top_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct counter_top_cfg * val; } parm1 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_SET_TOP_VALUE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_set_top_value(dev, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_set_top_value(dev, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_SET_TOP_VALUE, counter_set_top_value, dev, cfg); syscall__retval = counter_set_top_value(dev, cfg); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_SET_TOP_VALUE, counter_set_top_value, dev, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_get_pending_int(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_get_pending_int(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_GET_PENDING_INT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_pending_int(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_pending_int(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_PENDING_INT, counter_get_pending_int, dev); syscall__retval = counter_get_pending_int(dev); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_PENDING_INT, counter_get_pending_int, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_counter_get_top_value(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t counter_get_top_value(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_GET_TOP_VALUE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_top_value(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_top_value(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_TOP_VALUE, counter_get_top_value, dev); syscall__retval = counter_get_top_value(dev); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_TOP_VALUE, counter_get_top_value, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_counter_set_guard_period(const struct device * dev, uint32_t ticks, uint32_t flags);
|
||||
|
||||
__pinned_func
|
||||
static inline int counter_set_guard_period(const struct device * dev, uint32_t ticks, uint32_t flags)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = ticks };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = flags };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_COUNTER_SET_GUARD_PERIOD);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_set_guard_period(dev, ticks, flags);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_set_guard_period(dev, ticks, flags) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_SET_GUARD_PERIOD, counter_set_guard_period, dev, ticks, flags); syscall__retval = counter_set_guard_period(dev, ticks, flags); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_SET_GUARD_PERIOD, counter_set_guard_period, dev, ticks, flags, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_counter_get_guard_period(const struct device * dev, uint32_t flags);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t counter_get_guard_period(const struct device * dev, uint32_t flags)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = flags };
|
||||
return (uint32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_GET_GUARD_PERIOD);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_counter_get_guard_period(dev, flags);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define counter_get_guard_period(dev, flags) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_GUARD_PERIOD, counter_get_guard_period, dev, flags); syscall__retval = counter_get_guard_period(dev, flags); sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_GUARD_PERIOD, counter_get_guard_period, dev, flags, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,102 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_CRC_H
|
||||
#define Z_INCLUDE_SYSCALLS_CRC_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_crc_begin(const struct device * dev, struct crc_ctx * ctx);
|
||||
|
||||
__pinned_func
|
||||
static inline int crc_begin(const struct device * dev, struct crc_ctx * ctx)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct crc_ctx * val; } parm1 = { .val = ctx };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CRC_BEGIN);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_crc_begin(dev, ctx);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define crc_begin(dev, ctx) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CRC_BEGIN, crc_begin, dev, ctx); syscall__retval = crc_begin(dev, ctx); sys_port_trace_syscall_exit(K_SYSCALL_CRC_BEGIN, crc_begin, dev, ctx, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_crc_update(const struct device * dev, struct crc_ctx * ctx, const void * buffer, size_t bufsize);
|
||||
|
||||
__pinned_func
|
||||
static inline int crc_update(const struct device * dev, struct crc_ctx * ctx, const void * buffer, size_t bufsize)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct crc_ctx * val; } parm1 = { .val = ctx };
|
||||
union { uintptr_t x; const void * val; } parm2 = { .val = buffer };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = bufsize };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_CRC_UPDATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_crc_update(dev, ctx, buffer, bufsize);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define crc_update(dev, ctx, buffer, bufsize) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CRC_UPDATE, crc_update, dev, ctx, buffer, bufsize); syscall__retval = crc_update(dev, ctx, buffer, bufsize); sys_port_trace_syscall_exit(K_SYSCALL_CRC_UPDATE, crc_update, dev, ctx, buffer, bufsize, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_crc_finish(const struct device * dev, struct crc_ctx * ctx);
|
||||
|
||||
__pinned_func
|
||||
static inline int crc_finish(const struct device * dev, struct crc_ctx * ctx)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct crc_ctx * val; } parm1 = { .val = ctx };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CRC_FINISH);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_crc_finish(dev, ctx);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define crc_finish(dev, ctx) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_CRC_FINISH, crc_finish, dev, ctx); syscall__retval = crc_finish(dev, ctx); sys_port_trace_syscall_exit(K_SYSCALL_CRC_FINISH, crc_finish, dev, ctx, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,77 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_DAC_H
|
||||
#define Z_INCLUDE_SYSCALLS_DAC_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_dac_channel_setup(const struct device * dev, const struct dac_channel_cfg * channel_cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int dac_channel_setup(const struct device * dev, const struct dac_channel_cfg * channel_cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct dac_channel_cfg * val; } parm1 = { .val = channel_cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DAC_CHANNEL_SETUP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dac_channel_setup(dev, channel_cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dac_channel_setup(dev, channel_cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAC_CHANNEL_SETUP, dac_channel_setup, dev, channel_cfg); syscall__retval = dac_channel_setup(dev, channel_cfg); sys_port_trace_syscall_exit(K_SYSCALL_DAC_CHANNEL_SETUP, dac_channel_setup, dev, channel_cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_dac_write_value(const struct device * dev, uint8_t channel, uint32_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline int dac_write_value(const struct device * dev, uint8_t channel, uint32_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = channel };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = value };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_DAC_WRITE_VALUE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_dac_write_value(dev, channel, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define dac_write_value(dev, channel, value) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DAC_WRITE_VALUE, dac_write_value, dev, channel, value); syscall__retval = dac_write_value(dev, channel, value); sys_port_trace_syscall_exit(K_SYSCALL_DAC_WRITE_VALUE, dac_write_value, dev, channel, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,149 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_DEMAND_PAGING_H
|
||||
#define Z_INCLUDE_SYSCALLS_DEMAND_PAGING_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_k_mem_paging_stats_get(struct k_mem_paging_stats_t * stats);
|
||||
|
||||
__pinned_func
|
||||
static inline void k_mem_paging_stats_get(struct k_mem_paging_stats_t * stats)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct k_mem_paging_stats_t * val; } parm0 = { .val = stats };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MEM_PAGING_STATS_GET);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_k_mem_paging_stats_get(stats);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_mem_paging_stats_get(stats) do { sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_STATS_GET, k_mem_paging_stats_get, stats); k_mem_paging_stats_get(stats); sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_STATS_GET, k_mem_paging_stats_get, stats); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_k_mem_paging_thread_stats_get(struct k_thread * thread, struct k_mem_paging_stats_t * stats);
|
||||
|
||||
__pinned_func
|
||||
static inline void k_mem_paging_thread_stats_get(struct k_thread * thread, struct k_mem_paging_stats_t * stats)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct k_thread * val; } parm0 = { .val = thread };
|
||||
union { uintptr_t x; struct k_mem_paging_stats_t * val; } parm1 = { .val = stats };
|
||||
(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_k_mem_paging_thread_stats_get(thread, stats);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_mem_paging_thread_stats_get(thread, stats) do { sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET, k_mem_paging_thread_stats_get, thread, stats); k_mem_paging_thread_stats_get(thread, stats); sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET, k_mem_paging_thread_stats_get, thread, stats); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_k_mem_paging_histogram_eviction_get(struct k_mem_paging_histogram_t * hist);
|
||||
|
||||
__pinned_func
|
||||
static inline void k_mem_paging_histogram_eviction_get(struct k_mem_paging_histogram_t * hist)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct k_mem_paging_histogram_t * val; } parm0 = { .val = hist };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_k_mem_paging_histogram_eviction_get(hist);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_mem_paging_histogram_eviction_get(hist) do { sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET, k_mem_paging_histogram_eviction_get, hist); k_mem_paging_histogram_eviction_get(hist); sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET, k_mem_paging_histogram_eviction_get, hist); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_k_mem_paging_histogram_backing_store_page_in_get(struct k_mem_paging_histogram_t * hist);
|
||||
|
||||
__pinned_func
|
||||
static inline void k_mem_paging_histogram_backing_store_page_in_get(struct k_mem_paging_histogram_t * hist)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct k_mem_paging_histogram_t * val; } parm0 = { .val = hist };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_k_mem_paging_histogram_backing_store_page_in_get(hist);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_mem_paging_histogram_backing_store_page_in_get(hist) do { sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET, k_mem_paging_histogram_backing_store_page_in_get, hist); k_mem_paging_histogram_backing_store_page_in_get(hist); sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET, k_mem_paging_histogram_backing_store_page_in_get, hist); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_k_mem_paging_histogram_backing_store_page_out_get(struct k_mem_paging_histogram_t * hist);
|
||||
|
||||
__pinned_func
|
||||
static inline void k_mem_paging_histogram_backing_store_page_out_get(struct k_mem_paging_histogram_t * hist)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct k_mem_paging_histogram_t * val; } parm0 = { .val = hist };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_k_mem_paging_histogram_backing_store_page_out_get(hist);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define k_mem_paging_histogram_backing_store_page_out_get(hist) do { sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET, k_mem_paging_histogram_backing_store_page_out_get, hist); k_mem_paging_histogram_backing_store_page_out_get(hist); sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET, k_mem_paging_histogram_backing_store_page_out_get, hist); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,143 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_DEVICE_H
|
||||
#define Z_INCLUDE_SYSCALLS_DEVICE_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern const struct device * z_impl_device_get_binding(const char * name);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct device * device_get_binding(const char * name)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const char * val; } parm0 = { .val = name };
|
||||
return (const struct device *) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVICE_GET_BINDING);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_device_get_binding(name);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define device_get_binding(name) ({ const struct device * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DEVICE_GET_BINDING, device_get_binding, name); syscall__retval = device_get_binding(name); sys_port_trace_syscall_exit(K_SYSCALL_DEVICE_GET_BINDING, device_get_binding, name, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_device_is_ready(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline bool device_is_ready(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (bool) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVICE_IS_READY);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_device_is_ready(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define device_is_ready(dev) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DEVICE_IS_READY, device_is_ready, dev); syscall__retval = device_is_ready(dev); sys_port_trace_syscall_exit(K_SYSCALL_DEVICE_IS_READY, device_is_ready, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_device_init(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int device_init(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVICE_INIT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_device_init(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define device_init(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DEVICE_INIT, device_init, dev); syscall__retval = device_init(dev); sys_port_trace_syscall_exit(K_SYSCALL_DEVICE_INIT, device_init, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_device_deinit(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int device_deinit(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVICE_DEINIT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_device_deinit(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define device_deinit(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DEVICE_DEINIT, device_deinit, dev); syscall__retval = device_deinit(dev); sys_port_trace_syscall_exit(K_SYSCALL_DEVICE_DEINIT, device_deinit, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern const struct device * z_impl_device_get_by_dt_nodelabel(const char * nodelabel);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct device * device_get_by_dt_nodelabel(const char * nodelabel)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const char * val; } parm0 = { .val = nodelabel };
|
||||
return (const struct device *) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVICE_GET_BY_DT_NODELABEL);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_device_get_by_dt_nodelabel(nodelabel);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define device_get_by_dt_nodelabel(nodelabel) ({ const struct device * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DEVICE_GET_BY_DT_NODELABEL, device_get_by_dt_nodelabel, nodelabel); syscall__retval = device_get_by_dt_nodelabel(nodelabel); sys_port_trace_syscall_exit(K_SYSCALL_DEVICE_GET_BY_DT_NODELABEL, device_get_by_dt_nodelabel, nodelabel, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,75 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_DEVMUX_H
|
||||
#define Z_INCLUDE_SYSCALLS_DEVMUX_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_devmux_select_get(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int devmux_select_get(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVMUX_SELECT_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_devmux_select_get(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define devmux_select_get(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DEVMUX_SELECT_GET, devmux_select_get, dev); syscall__retval = devmux_select_get(dev); sys_port_trace_syscall_exit(K_SYSCALL_DEVMUX_SELECT_GET, devmux_select_get, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_devmux_select_set(struct device * dev, size_t index);
|
||||
|
||||
__pinned_func
|
||||
static inline int devmux_select_set(struct device * dev, size_t index)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = index };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DEVMUX_SELECT_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_devmux_select_set(dev, index);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define devmux_select_set(dev, index) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_DEVMUX_SELECT_SET, devmux_select_set, dev, index); syscall__retval = devmux_select_set(dev, index); sys_port_trace_syscall_exit(K_SYSCALL_DEVMUX_SELECT_SET, devmux_select_set, dev, index, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,103 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_EEPROM_H
|
||||
#define Z_INCLUDE_SYSCALLS_EEPROM_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_eeprom_read(const struct device * dev, off_t offset, void * data, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int eeprom_read(const struct device * dev, off_t offset, void * data, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; void * val; } parm2 = { .val = data };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_EEPROM_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_eeprom_read(dev, offset, data, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define eeprom_read(dev, offset, data, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_EEPROM_READ, eeprom_read, dev, offset, data, len); syscall__retval = eeprom_read(dev, offset, data, len); sys_port_trace_syscall_exit(K_SYSCALL_EEPROM_READ, eeprom_read, dev, offset, data, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_eeprom_write(const struct device * dev, off_t offset, const void * data, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int eeprom_write(const struct device * dev, off_t offset, const void * data, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; const void * val; } parm2 = { .val = data };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_EEPROM_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_eeprom_write(dev, offset, data, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define eeprom_write(dev, offset, data, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_EEPROM_WRITE, eeprom_write, dev, offset, data, len); syscall__retval = eeprom_write(dev, offset, data, len); sys_port_trace_syscall_exit(K_SYSCALL_EEPROM_WRITE, eeprom_write, dev, offset, data, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern size_t z_impl_eeprom_get_size(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline size_t eeprom_get_size(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (size_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_EEPROM_GET_SIZE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_eeprom_get_size(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define eeprom_get_size(dev) ({ size_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_EEPROM_GET_SIZE, eeprom_get_size, dev); syscall__retval = eeprom_get_size(dev); sys_port_trace_syscall_exit(K_SYSCALL_EEPROM_GET_SIZE, eeprom_get_size, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,77 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_EMUL_FUEL_GAUGE_H
|
||||
#define Z_INCLUDE_SYSCALLS_EMUL_FUEL_GAUGE_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_emul_fuel_gauge_set_battery_charging(const struct emul * target, uint32_t uV, int uA);
|
||||
|
||||
__pinned_func
|
||||
static inline int emul_fuel_gauge_set_battery_charging(const struct emul * target, uint32_t uV, int uA)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct emul * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = uV };
|
||||
union { uintptr_t x; int val; } parm2 = { .val = uA };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_emul_fuel_gauge_set_battery_charging(target, uV, uA);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define emul_fuel_gauge_set_battery_charging(target, uV, uA) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING, emul_fuel_gauge_set_battery_charging, target, uV, uA); syscall__retval = emul_fuel_gauge_set_battery_charging(target, uV, uA); sys_port_trace_syscall_exit(K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING, emul_fuel_gauge_set_battery_charging, target, uV, uA, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_emul_fuel_gauge_is_battery_cutoff(const struct emul * target, bool * cutoff);
|
||||
|
||||
__pinned_func
|
||||
static inline int emul_fuel_gauge_is_battery_cutoff(const struct emul * target, bool * cutoff)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct emul * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; bool * val; } parm1 = { .val = cutoff };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_emul_fuel_gauge_is_battery_cutoff(target, cutoff);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define emul_fuel_gauge_is_battery_cutoff(target, cutoff) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF, emul_fuel_gauge_is_battery_cutoff, target, cutoff); syscall__retval = emul_fuel_gauge_is_battery_cutoff(target, cutoff); sys_port_trace_syscall_exit(K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF, emul_fuel_gauge_is_battery_cutoff, target, cutoff, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,53 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ENTROPY_H
|
||||
#define Z_INCLUDE_SYSCALLS_ENTROPY_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_entropy_get_entropy(const struct device * dev, uint8_t * buffer, uint16_t length);
|
||||
|
||||
__pinned_func
|
||||
static inline int entropy_get_entropy(const struct device * dev, uint8_t * buffer, uint16_t length)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t * val; } parm1 = { .val = buffer };
|
||||
union { uintptr_t x; uint16_t val; } parm2 = { .val = length };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ENTROPY_GET_ENTROPY);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_entropy_get_entropy(dev, buffer, length);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define entropy_get_entropy(dev, buffer, length) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ENTROPY_GET_ENTROPY, entropy_get_entropy, dev, buffer, length); syscall__retval = entropy_get_entropy(dev, buffer, length); sys_port_trace_syscall_exit(K_SYSCALL_ENTROPY_GET_ENTROPY, entropy_get_entropy, dev, buffer, length, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,43 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ERRNO_PRIVATE_H
|
||||
#define Z_INCLUDE_SYSCALLS_ERRNO_PRIVATE_H
|
||||
|
||||
|
||||
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int * z_impl_z_errno(void);
|
||||
|
||||
__pinned_func
|
||||
static inline int * z_errno(void)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
return (int *) arch_syscall_invoke0(K_SYSCALL_Z_ERRNO);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_z_errno();
|
||||
}
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,52 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ERROR_H
|
||||
#define Z_INCLUDE_SYSCALLS_ERROR_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_user_fault(unsigned int reason);
|
||||
|
||||
__pinned_func
|
||||
static inline void user_fault(unsigned int reason)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; unsigned int val; } parm0 = { .val = reason };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_USER_FAULT);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_user_fault(reason);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define user_fault(reason) do { sys_port_trace_syscall_enter(K_SYSCALL_USER_FAULT, user_fault, reason); user_fault(reason); sys_port_trace_syscall_exit(K_SYSCALL_USER_FAULT, user_fault, reason); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,344 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ESPI_H
|
||||
#define Z_INCLUDE_SYSCALLS_ESPI_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_espi_config(const struct device * dev, struct espi_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_config(const struct device * dev, struct espi_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_cfg * val; } parm1 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_config(dev, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_config(dev, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_CONFIG, espi_config, dev, cfg); syscall__retval = espi_config(dev, cfg); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_CONFIG, espi_config, dev, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_espi_get_channel_status(const struct device * dev, enum espi_channel ch);
|
||||
|
||||
__pinned_func
|
||||
static inline bool espi_get_channel_status(const struct device * dev, enum espi_channel ch)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum espi_channel val; } parm1 = { .val = ch };
|
||||
return (bool) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_GET_CHANNEL_STATUS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_get_channel_status(dev, ch);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_get_channel_status(dev, ch) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_GET_CHANNEL_STATUS, espi_get_channel_status, dev, ch); syscall__retval = espi_get_channel_status(dev, ch); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_GET_CHANNEL_STATUS, espi_get_channel_status, dev, ch, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_read_request(const struct device * dev, struct espi_request_packet * req);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_read_request(const struct device * dev, struct espi_request_packet * req)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_request_packet * val; } parm1 = { .val = req };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_READ_REQUEST);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_read_request(dev, req);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_read_request(dev, req) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_READ_REQUEST, espi_read_request, dev, req); syscall__retval = espi_read_request(dev, req); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_READ_REQUEST, espi_read_request, dev, req, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_write_request(const struct device * dev, struct espi_request_packet * req);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_write_request(const struct device * dev, struct espi_request_packet * req)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_request_packet * val; } parm1 = { .val = req };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_WRITE_REQUEST);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_write_request(dev, req);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_write_request(dev, req) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_WRITE_REQUEST, espi_write_request, dev, req); syscall__retval = espi_write_request(dev, req); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_WRITE_REQUEST, espi_write_request, dev, req, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_read_lpc_request(const struct device * dev, enum lpc_peripheral_opcode op, uint32_t * data);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_read_lpc_request(const struct device * dev, enum lpc_peripheral_opcode op, uint32_t * data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum lpc_peripheral_opcode val; } parm1 = { .val = op };
|
||||
union { uintptr_t x; uint32_t * val; } parm2 = { .val = data };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ESPI_READ_LPC_REQUEST);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_read_lpc_request(dev, op, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_read_lpc_request(dev, op, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_READ_LPC_REQUEST, espi_read_lpc_request, dev, op, data); syscall__retval = espi_read_lpc_request(dev, op, data); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_READ_LPC_REQUEST, espi_read_lpc_request, dev, op, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_write_lpc_request(const struct device * dev, enum lpc_peripheral_opcode op, uint32_t * data);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_write_lpc_request(const struct device * dev, enum lpc_peripheral_opcode op, uint32_t * data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum lpc_peripheral_opcode val; } parm1 = { .val = op };
|
||||
union { uintptr_t x; uint32_t * val; } parm2 = { .val = data };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ESPI_WRITE_LPC_REQUEST);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_write_lpc_request(dev, op, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_write_lpc_request(dev, op, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_WRITE_LPC_REQUEST, espi_write_lpc_request, dev, op, data); syscall__retval = espi_write_lpc_request(dev, op, data); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_WRITE_LPC_REQUEST, espi_write_lpc_request, dev, op, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_send_vwire(const struct device * dev, enum espi_vwire_signal signal, uint8_t level);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_send_vwire(const struct device * dev, enum espi_vwire_signal signal, uint8_t level)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum espi_vwire_signal val; } parm1 = { .val = signal };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = level };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ESPI_SEND_VWIRE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_send_vwire(dev, signal, level);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_send_vwire(dev, signal, level) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SEND_VWIRE, espi_send_vwire, dev, signal, level); syscall__retval = espi_send_vwire(dev, signal, level); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SEND_VWIRE, espi_send_vwire, dev, signal, level, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_receive_vwire(const struct device * dev, enum espi_vwire_signal signal, uint8_t * level);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_receive_vwire(const struct device * dev, enum espi_vwire_signal signal, uint8_t * level)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum espi_vwire_signal val; } parm1 = { .val = signal };
|
||||
union { uintptr_t x; uint8_t * val; } parm2 = { .val = level };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ESPI_RECEIVE_VWIRE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_receive_vwire(dev, signal, level);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_receive_vwire(dev, signal, level) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_RECEIVE_VWIRE, espi_receive_vwire, dev, signal, level); syscall__retval = espi_receive_vwire(dev, signal, level); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_RECEIVE_VWIRE, espi_receive_vwire, dev, signal, level, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_send_oob(const struct device * dev, struct espi_oob_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_send_oob(const struct device * dev, struct espi_oob_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_oob_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SEND_OOB);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_send_oob(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_send_oob(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SEND_OOB, espi_send_oob, dev, pckt); syscall__retval = espi_send_oob(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SEND_OOB, espi_send_oob, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_receive_oob(const struct device * dev, struct espi_oob_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_receive_oob(const struct device * dev, struct espi_oob_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_oob_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_RECEIVE_OOB);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_receive_oob(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_receive_oob(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_RECEIVE_OOB, espi_receive_oob, dev, pckt); syscall__retval = espi_receive_oob(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_RECEIVE_OOB, espi_receive_oob, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_read_flash(const struct device * dev, struct espi_flash_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_read_flash(const struct device * dev, struct espi_flash_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_flash_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_READ_FLASH);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_read_flash(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_read_flash(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_READ_FLASH, espi_read_flash, dev, pckt); syscall__retval = espi_read_flash(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_READ_FLASH, espi_read_flash, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_write_flash(const struct device * dev, struct espi_flash_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_write_flash(const struct device * dev, struct espi_flash_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_flash_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_WRITE_FLASH);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_write_flash(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_write_flash(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_WRITE_FLASH, espi_write_flash, dev, pckt); syscall__retval = espi_write_flash(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_WRITE_FLASH, espi_write_flash, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_flash_erase(const struct device * dev, struct espi_flash_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_flash_erase(const struct device * dev, struct espi_flash_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_flash_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_FLASH_ERASE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_flash_erase(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_flash_erase(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_FLASH_ERASE, espi_flash_erase, dev, pckt); syscall__retval = espi_flash_erase(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_FLASH_ERASE, espi_flash_erase, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,218 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ESPI_SAF_H
|
||||
#define Z_INCLUDE_SYSCALLS_ESPI_SAF_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_espi_saf_config(const struct device * dev, const struct espi_saf_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_saf_config(const struct device * dev, const struct espi_saf_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct espi_saf_cfg * val; } parm1 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_config(dev, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_config(dev, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_CONFIG, espi_saf_config, dev, cfg); syscall__retval = espi_saf_config(dev, cfg); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_CONFIG, espi_saf_config, dev, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_saf_set_protection_regions(const struct device * dev, const struct espi_saf_protection * pr);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_saf_set_protection_regions(const struct device * dev, const struct espi_saf_protection * pr)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct espi_saf_protection * val; } parm1 = { .val = pr };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_set_protection_regions(dev, pr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_set_protection_regions(dev, pr) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS, espi_saf_set_protection_regions, dev, pr); syscall__retval = espi_saf_set_protection_regions(dev, pr); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS, espi_saf_set_protection_regions, dev, pr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_saf_activate(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_saf_activate(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_ESPI_SAF_ACTIVATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_activate(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_activate(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_ACTIVATE, espi_saf_activate, dev); syscall__retval = espi_saf_activate(dev); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_ACTIVATE, espi_saf_activate, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_espi_saf_get_channel_status(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline bool espi_saf_get_channel_status(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (bool) arch_syscall_invoke1(parm0.x, K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_get_channel_status(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_get_channel_status(dev) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS, espi_saf_get_channel_status, dev); syscall__retval = espi_saf_get_channel_status(dev); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS, espi_saf_get_channel_status, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_saf_flash_read(const struct device * dev, struct espi_saf_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_saf_flash_read(const struct device * dev, struct espi_saf_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_saf_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_FLASH_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_flash_read(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_flash_read(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_FLASH_READ, espi_saf_flash_read, dev, pckt); syscall__retval = espi_saf_flash_read(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_FLASH_READ, espi_saf_flash_read, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_saf_flash_write(const struct device * dev, struct espi_saf_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_saf_flash_write(const struct device * dev, struct espi_saf_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_saf_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_FLASH_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_flash_write(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_flash_write(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_FLASH_WRITE, espi_saf_flash_write, dev, pckt); syscall__retval = espi_saf_flash_write(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_FLASH_WRITE, espi_saf_flash_write, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_saf_flash_erase(const struct device * dev, struct espi_saf_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_saf_flash_erase(const struct device * dev, struct espi_saf_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_saf_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_FLASH_ERASE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_flash_erase(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_flash_erase(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_FLASH_ERASE, espi_saf_flash_erase, dev, pckt); syscall__retval = espi_saf_flash_erase(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_FLASH_ERASE, espi_saf_flash_erase, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_espi_saf_flash_unsuccess(const struct device * dev, struct espi_saf_packet * pckt);
|
||||
|
||||
__pinned_func
|
||||
static inline int espi_saf_flash_unsuccess(const struct device * dev, struct espi_saf_packet * pckt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct espi_saf_packet * val; } parm1 = { .val = pckt };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_espi_saf_flash_unsuccess(dev, pckt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define espi_saf_flash_unsuccess(dev, pckt) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS, espi_saf_flash_unsuccess, dev, pckt); syscall__retval = espi_saf_flash_unsuccess(dev, pckt); sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS, espi_saf_flash_unsuccess, dev, pckt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,51 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_ETHERNET_H
|
||||
#define Z_INCLUDE_SYSCALLS_ETHERNET_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern const struct device * z_impl_net_eth_get_ptp_clock_by_index(int index);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct device * net_eth_get_ptp_clock_by_index(int index)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = index };
|
||||
return (const struct device *) arch_syscall_invoke1(parm0.x, K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_eth_get_ptp_clock_by_index(index);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_eth_get_ptp_clock_by_index(index) ({ const struct device * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX, net_eth_get_ptp_clock_by_index, index); syscall__retval = net_eth_get_ptp_clock_by_index(index); sys_port_trace_syscall_exit(K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX, net_eth_get_ptp_clock_by_index, index, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,81 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_FDTABLE_H
|
||||
#define Z_INCLUDE_SYSCALLS_FDTABLE_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_zvfs_poll(struct zvfs_pollfd * fds, int nfds, int poll_timeout);
|
||||
|
||||
__pinned_func
|
||||
static inline int zvfs_poll(struct zvfs_pollfd * fds, int nfds, int poll_timeout)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct zvfs_pollfd * val; } parm0 = { .val = fds };
|
||||
union { uintptr_t x; int val; } parm1 = { .val = nfds };
|
||||
union { uintptr_t x; int val; } parm2 = { .val = poll_timeout };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ZVFS_POLL);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_zvfs_poll(fds, nfds, poll_timeout);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define zvfs_poll(fds, nfds, poll_timeout) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ZVFS_POLL, zvfs_poll, fds, nfds, poll_timeout); syscall__retval = zvfs_poll(fds, nfds, poll_timeout); sys_port_trace_syscall_exit(K_SYSCALL_ZVFS_POLL, zvfs_poll, fds, nfds, poll_timeout, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_zvfs_select(int nfds, struct zvfs_fd_set *ZRESTRICT readfds, struct zvfs_fd_set *ZRESTRICT writefds, struct zvfs_fd_set *ZRESTRICT errorfds, const struct timespec *ZRESTRICT timeout, const void *ZRESTRICT sigmask);
|
||||
|
||||
__pinned_func
|
||||
static inline int zvfs_select(int nfds, struct zvfs_fd_set *ZRESTRICT readfds, struct zvfs_fd_set *ZRESTRICT writefds, struct zvfs_fd_set *ZRESTRICT errorfds, const struct timespec *ZRESTRICT timeout, const void *ZRESTRICT sigmask)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = nfds };
|
||||
union { uintptr_t x; struct zvfs_fd_set *ZRESTRICT val; } parm1 = { .val = readfds };
|
||||
union { uintptr_t x; struct zvfs_fd_set *ZRESTRICT val; } parm2 = { .val = writefds };
|
||||
union { uintptr_t x; struct zvfs_fd_set *ZRESTRICT val; } parm3 = { .val = errorfds };
|
||||
union { uintptr_t x; const struct timespec *ZRESTRICT val; } parm4 = { .val = timeout };
|
||||
union { uintptr_t x; const void *ZRESTRICT val; } parm5 = { .val = sigmask };
|
||||
return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, parm5.x, K_SYSCALL_ZVFS_SELECT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_zvfs_select(nfds, readfds, writefds, errorfds, timeout, sigmask);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define zvfs_select(nfds, readfds, writefds, errorfds, timeout, sigmask) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ZVFS_SELECT, zvfs_select, nfds, readfds, writefds, errorfds, timeout, sigmask); syscall__retval = zvfs_select(nfds, readfds, writefds, errorfds, timeout, sigmask); sys_port_trace_syscall_exit(K_SYSCALL_ZVFS_SELECT, zvfs_select, nfds, readfds, writefds, errorfds, timeout, sigmask, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,408 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_FLASH_H
|
||||
#define Z_INCLUDE_SYSCALLS_FLASH_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_flash_read(const struct device * dev, off_t offset, void * data, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_read(const struct device * dev, off_t offset, void * data, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; void * val; } parm2 = { .val = data };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FLASH_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_read(dev, offset, data, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_read(dev, offset, data, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_READ, flash_read, dev, offset, data, len); syscall__retval = flash_read(dev, offset, data, len); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_READ, flash_read, dev, offset, data, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_write(const struct device * dev, off_t offset, const void * data, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_write(const struct device * dev, off_t offset, const void * data, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; const void * val; } parm2 = { .val = data };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FLASH_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_write(dev, offset, data, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_write(dev, offset, data, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_WRITE, flash_write, dev, offset, data, len); syscall__retval = flash_write(dev, offset, data, len); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_WRITE, flash_write, dev, offset, data, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_erase(const struct device * dev, off_t offset, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_erase(const struct device * dev, off_t offset, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = size };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FLASH_ERASE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_erase(dev, offset, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_erase(dev, offset, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_ERASE, flash_erase, dev, offset, size); syscall__retval = flash_erase(dev, offset, size); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_ERASE, flash_erase, dev, offset, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_get_size(const struct device * dev, uint64_t * size);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_get_size(const struct device * dev, uint64_t * size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint64_t * val; } parm1 = { .val = size };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_FLASH_GET_SIZE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_get_size(dev, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_get_size(dev, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_SIZE, flash_get_size, dev, size); syscall__retval = flash_get_size(dev, size); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_SIZE, flash_get_size, dev, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_fill(const struct device * dev, uint8_t val, off_t offset, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_fill(const struct device * dev, uint8_t val, off_t offset, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = val };
|
||||
union { uintptr_t x; off_t val; } parm2 = { .val = offset };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = size };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FLASH_FILL);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_fill(dev, val, offset, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_fill(dev, val, offset, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_FILL, flash_fill, dev, val, offset, size); syscall__retval = flash_fill(dev, val, offset, size); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_FILL, flash_fill, dev, val, offset, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_flatten(const struct device * dev, off_t offset, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_flatten(const struct device * dev, off_t offset, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = size };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FLASH_FLATTEN);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_flatten(dev, offset, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_flatten(dev, offset, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_FLATTEN, flash_flatten, dev, offset, size); syscall__retval = flash_flatten(dev, offset, size); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_FLATTEN, flash_flatten, dev, offset, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_get_page_info_by_offs(const struct device * dev, off_t offset, struct flash_pages_info * info);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_get_page_info_by_offs(const struct device * dev, off_t offset, struct flash_pages_info * info)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; struct flash_pages_info * val; } parm2 = { .val = info };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_get_page_info_by_offs(dev, offset, info);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_get_page_info_by_offs(dev, offset, info) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS, flash_get_page_info_by_offs, dev, offset, info); syscall__retval = flash_get_page_info_by_offs(dev, offset, info); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS, flash_get_page_info_by_offs, dev, offset, info, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_get_page_info_by_idx(const struct device * dev, uint32_t page_index, struct flash_pages_info * info);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_get_page_info_by_idx(const struct device * dev, uint32_t page_index, struct flash_pages_info * info)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = page_index };
|
||||
union { uintptr_t x; struct flash_pages_info * val; } parm2 = { .val = info };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_get_page_info_by_idx(dev, page_index, info);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_get_page_info_by_idx(dev, page_index, info) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX, flash_get_page_info_by_idx, dev, page_index, info); syscall__retval = flash_get_page_info_by_idx(dev, page_index, info); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX, flash_get_page_info_by_idx, dev, page_index, info, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern size_t z_impl_flash_get_page_count(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline size_t flash_get_page_count(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (size_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_FLASH_GET_PAGE_COUNT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_get_page_count(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_get_page_count(dev) ({ size_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_PAGE_COUNT, flash_get_page_count, dev); syscall__retval = flash_get_page_count(dev); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_PAGE_COUNT, flash_get_page_count, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_sfdp_read(const struct device * dev, off_t offset, void * data, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_sfdp_read(const struct device * dev, off_t offset, void * data, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = offset };
|
||||
union { uintptr_t x; void * val; } parm2 = { .val = data };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FLASH_SFDP_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_sfdp_read(dev, offset, data, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_sfdp_read(dev, offset, data, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_SFDP_READ, flash_sfdp_read, dev, offset, data, len); syscall__retval = flash_sfdp_read(dev, offset, data, len); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_SFDP_READ, flash_sfdp_read, dev, offset, data, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_read_jedec_id(const struct device * dev, uint8_t * id);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_read_jedec_id(const struct device * dev, uint8_t * id)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t * val; } parm1 = { .val = id };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_FLASH_READ_JEDEC_ID);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_read_jedec_id(dev, id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_read_jedec_id(dev, id) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_READ_JEDEC_ID, flash_read_jedec_id, dev, id); syscall__retval = flash_read_jedec_id(dev, id); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_READ_JEDEC_ID, flash_read_jedec_id, dev, id, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern size_t z_impl_flash_get_write_block_size(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline size_t flash_get_write_block_size(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (size_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_get_write_block_size(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_get_write_block_size(dev) ({ size_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE, flash_get_write_block_size, dev); syscall__retval = flash_get_write_block_size(dev); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE, flash_get_write_block_size, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern const struct flash_parameters * z_impl_flash_get_parameters(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline const struct flash_parameters * flash_get_parameters(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (const struct flash_parameters *) arch_syscall_invoke1(parm0.x, K_SYSCALL_FLASH_GET_PARAMETERS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_get_parameters(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_get_parameters(dev) ({ const struct flash_parameters * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_PARAMETERS, flash_get_parameters, dev); syscall__retval = flash_get_parameters(dev); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_PARAMETERS, flash_get_parameters, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_ex_op(const struct device * dev, uint16_t code, const uintptr_t in, void * out);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_ex_op(const struct device * dev, uint16_t code, const uintptr_t in, void * out)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint16_t val; } parm1 = { .val = code };
|
||||
union { uintptr_t x; const uintptr_t val; } parm2 = { .val = in };
|
||||
union { uintptr_t x; void * val; } parm3 = { .val = out };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FLASH_EX_OP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_ex_op(dev, code, in, out);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_ex_op(dev, code, in, out) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_EX_OP, flash_ex_op, dev, code, in, out); syscall__retval = flash_ex_op(dev, code, in, out); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_EX_OP, flash_ex_op, dev, code, in, out, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_flash_copy(const struct device * src_dev, off_t src_offset, const struct device * dst_dev, off_t dst_offset, off_t size, uint8_t * buf, size_t buf_size);
|
||||
|
||||
__pinned_func
|
||||
static inline int flash_copy(const struct device * src_dev, off_t src_offset, const struct device * dst_dev, off_t dst_offset, off_t size, uint8_t * buf, size_t buf_size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = src_dev };
|
||||
union { uintptr_t x; off_t val; } parm1 = { .val = src_offset };
|
||||
union { uintptr_t x; const struct device * val; } parm2 = { .val = dst_dev };
|
||||
union { uintptr_t x; off_t val; } parm3 = { .val = dst_offset };
|
||||
union { uintptr_t x; off_t val; } parm4 = { .val = size };
|
||||
union { uintptr_t x; uint8_t * val; } parm5 = { .val = buf };
|
||||
union { uintptr_t x; size_t val; } parm6 = { .val = buf_size };
|
||||
uintptr_t more[] = {
|
||||
parm5.x,
|
||||
parm6.x
|
||||
};
|
||||
return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, (uintptr_t) &more, K_SYSCALL_FLASH_COPY);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_flash_copy(src_dev, src_offset, dst_dev, dst_offset, size, buf, buf_size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define flash_copy(src_dev, src_offset, dst_dev, dst_offset, size, buf, buf_size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FLASH_COPY, flash_copy, src_dev, src_offset, dst_dev, dst_offset, size, buf, buf_size); syscall__retval = flash_copy(src_dev, src_offset, dst_dev, dst_offset, size, buf, buf_size); sys_port_trace_syscall_exit(K_SYSCALL_FLASH_COPY, flash_copy, src_dev, src_offset, dst_dev, dst_offset, size, buf, buf_size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,52 @@
|
||||
/* 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 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 */
|
||||
@@ -0,0 +1,179 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_FUEL_GAUGE_H
|
||||
#define Z_INCLUDE_SYSCALLS_FUEL_GAUGE_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_fuel_gauge_get_prop(const struct device * dev, fuel_gauge_prop_t prop, union fuel_gauge_prop_val * val);
|
||||
|
||||
__pinned_func
|
||||
static inline int fuel_gauge_get_prop(const struct device * dev, fuel_gauge_prop_t prop, union fuel_gauge_prop_val * val)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; fuel_gauge_prop_t val; } parm1 = { .val = prop };
|
||||
union { uintptr_t x; union fuel_gauge_prop_val * val; } parm2 = { .val = val };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FUEL_GAUGE_GET_PROP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_fuel_gauge_get_prop(dev, prop, val);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define fuel_gauge_get_prop(dev, prop, val) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_GET_PROP, fuel_gauge_get_prop, dev, prop, val); syscall__retval = fuel_gauge_get_prop(dev, prop, val); sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_GET_PROP, fuel_gauge_get_prop, dev, prop, val, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_fuel_gauge_get_props(const struct device * dev, const fuel_gauge_prop_t * props, union fuel_gauge_prop_val * vals, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int fuel_gauge_get_props(const struct device * dev, const fuel_gauge_prop_t * props, union fuel_gauge_prop_val * vals, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const fuel_gauge_prop_t * val; } parm1 = { .val = props };
|
||||
union { uintptr_t x; union fuel_gauge_prop_val * val; } parm2 = { .val = vals };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FUEL_GAUGE_GET_PROPS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_fuel_gauge_get_props(dev, props, vals, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define fuel_gauge_get_props(dev, props, vals, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_GET_PROPS, fuel_gauge_get_props, dev, props, vals, len); syscall__retval = fuel_gauge_get_props(dev, props, vals, len); sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_GET_PROPS, fuel_gauge_get_props, dev, props, vals, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_fuel_gauge_set_prop(const struct device * dev, fuel_gauge_prop_t prop, union fuel_gauge_prop_val val);
|
||||
|
||||
__pinned_func
|
||||
static inline int fuel_gauge_set_prop(const struct device * dev, fuel_gauge_prop_t prop, union fuel_gauge_prop_val val)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; fuel_gauge_prop_t val; } parm1 = { .val = prop };
|
||||
union { uintptr_t x; union fuel_gauge_prop_val val; } parm2 = { .val = val };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FUEL_GAUGE_SET_PROP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_fuel_gauge_set_prop(dev, prop, val);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define fuel_gauge_set_prop(dev, prop, val) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_SET_PROP, fuel_gauge_set_prop, dev, prop, val); syscall__retval = fuel_gauge_set_prop(dev, prop, val); sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_SET_PROP, fuel_gauge_set_prop, dev, prop, val, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_fuel_gauge_set_props(const struct device * dev, const fuel_gauge_prop_t * props, const union fuel_gauge_prop_val * vals, size_t len);
|
||||
|
||||
__pinned_func
|
||||
static inline int fuel_gauge_set_props(const struct device * dev, const fuel_gauge_prop_t * props, const union fuel_gauge_prop_val * vals, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const fuel_gauge_prop_t * val; } parm1 = { .val = props };
|
||||
union { uintptr_t x; const union fuel_gauge_prop_val * val; } parm2 = { .val = vals };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FUEL_GAUGE_SET_PROPS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_fuel_gauge_set_props(dev, props, vals, len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define fuel_gauge_set_props(dev, props, vals, len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_SET_PROPS, fuel_gauge_set_props, dev, props, vals, len); syscall__retval = fuel_gauge_set_props(dev, props, vals, len); sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_SET_PROPS, fuel_gauge_set_props, dev, props, vals, len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_fuel_gauge_get_buffer_prop(const struct device * dev, fuel_gauge_prop_t prop_type, void * dst, size_t dst_len);
|
||||
|
||||
__pinned_func
|
||||
static inline int fuel_gauge_get_buffer_prop(const struct device * dev, fuel_gauge_prop_t prop_type, void * dst, size_t dst_len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; fuel_gauge_prop_t val; } parm1 = { .val = prop_type };
|
||||
union { uintptr_t x; void * val; } parm2 = { .val = dst };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = dst_len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_fuel_gauge_get_buffer_prop(dev, prop_type, dst, dst_len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define fuel_gauge_get_buffer_prop(dev, prop_type, dst, dst_len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP, fuel_gauge_get_buffer_prop, dev, prop_type, dst, dst_len); syscall__retval = fuel_gauge_get_buffer_prop(dev, prop_type, dst, dst_len); sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP, fuel_gauge_get_buffer_prop, dev, prop_type, dst, dst_len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_fuel_gauge_battery_cutoff(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int fuel_gauge_battery_cutoff(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_fuel_gauge_battery_cutoff(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define fuel_gauge_battery_cutoff(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF, fuel_gauge_battery_cutoff, dev); syscall__retval = fuel_gauge_battery_cutoff(dev); sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF, fuel_gauge_battery_cutoff, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,220 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_GNSS_H
|
||||
#define Z_INCLUDE_SYSCALLS_GNSS_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_gnss_set_fix_rate(const struct device * dev, uint32_t fix_interval_ms);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_set_fix_rate(const struct device * dev, uint32_t fix_interval_ms)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = fix_interval_ms };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_SET_FIX_RATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_set_fix_rate(dev, fix_interval_ms);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_set_fix_rate(dev, fix_interval_ms) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_SET_FIX_RATE, gnss_set_fix_rate, dev, fix_interval_ms); syscall__retval = gnss_set_fix_rate(dev, fix_interval_ms); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_SET_FIX_RATE, gnss_set_fix_rate, dev, fix_interval_ms, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gnss_get_fix_rate(const struct device * dev, uint32_t * fix_interval_ms);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_get_fix_rate(const struct device * dev, uint32_t * fix_interval_ms)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t * val; } parm1 = { .val = fix_interval_ms };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_FIX_RATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_get_fix_rate(dev, fix_interval_ms);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_get_fix_rate(dev, fix_interval_ms) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_FIX_RATE, gnss_get_fix_rate, dev, fix_interval_ms); syscall__retval = gnss_get_fix_rate(dev, fix_interval_ms); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_FIX_RATE, gnss_get_fix_rate, dev, fix_interval_ms, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gnss_set_navigation_mode(const struct device * dev, enum gnss_navigation_mode mode);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_set_navigation_mode(const struct device * dev, enum gnss_navigation_mode mode)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum gnss_navigation_mode val; } parm1 = { .val = mode };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_SET_NAVIGATION_MODE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_set_navigation_mode(dev, mode);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_set_navigation_mode(dev, mode) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_SET_NAVIGATION_MODE, gnss_set_navigation_mode, dev, mode); syscall__retval = gnss_set_navigation_mode(dev, mode); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_SET_NAVIGATION_MODE, gnss_set_navigation_mode, dev, mode, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gnss_get_navigation_mode(const struct device * dev, enum gnss_navigation_mode * mode);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_get_navigation_mode(const struct device * dev, enum gnss_navigation_mode * mode)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum gnss_navigation_mode * val; } parm1 = { .val = mode };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_NAVIGATION_MODE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_get_navigation_mode(dev, mode);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_get_navigation_mode(dev, mode) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_NAVIGATION_MODE, gnss_get_navigation_mode, dev, mode); syscall__retval = gnss_get_navigation_mode(dev, mode); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_NAVIGATION_MODE, gnss_get_navigation_mode, dev, mode, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gnss_set_enabled_systems(const struct device * dev, gnss_systems_t systems);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_set_enabled_systems(const struct device * dev, gnss_systems_t systems)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; gnss_systems_t val; } parm1 = { .val = systems };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_set_enabled_systems(dev, systems);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_set_enabled_systems(dev, systems) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS, gnss_set_enabled_systems, dev, systems); syscall__retval = gnss_set_enabled_systems(dev, systems); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS, gnss_set_enabled_systems, dev, systems, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gnss_get_enabled_systems(const struct device * dev, gnss_systems_t * systems);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_get_enabled_systems(const struct device * dev, gnss_systems_t * systems)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; gnss_systems_t * val; } parm1 = { .val = systems };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_get_enabled_systems(dev, systems);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_get_enabled_systems(dev, systems) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS, gnss_get_enabled_systems, dev, systems); syscall__retval = gnss_get_enabled_systems(dev, systems); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS, gnss_get_enabled_systems, dev, systems, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gnss_get_supported_systems(const struct device * dev, gnss_systems_t * systems);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_get_supported_systems(const struct device * dev, gnss_systems_t * systems)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; gnss_systems_t * val; } parm1 = { .val = systems };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_get_supported_systems(dev, systems);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_get_supported_systems(dev, systems) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS, gnss_get_supported_systems, dev, systems); syscall__retval = gnss_get_supported_systems(dev, systems); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS, gnss_get_supported_systems, dev, systems, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gnss_get_latest_timepulse(const struct device * dev, k_ticks_t * timestamp);
|
||||
|
||||
__pinned_func
|
||||
static inline int gnss_get_latest_timepulse(const struct device * dev, k_ticks_t * timestamp)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; k_ticks_t * val; } parm1 = { .val = timestamp };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_LATEST_TIMEPULSE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gnss_get_latest_timepulse(dev, timestamp);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gnss_get_latest_timepulse(dev, timestamp) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_LATEST_TIMEPULSE, gnss_get_latest_timepulse, dev, timestamp); syscall__retval = gnss_get_latest_timepulse(dev, timestamp); sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_LATEST_TIMEPULSE, gnss_get_latest_timepulse, dev, timestamp, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,273 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_GPIO_H
|
||||
#define Z_INCLUDE_SYSCALLS_GPIO_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_gpio_pin_interrupt_configure(const struct device * port, gpio_pin_t pin, gpio_flags_t flags);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_pin_interrupt_configure(const struct device * port, gpio_pin_t pin, gpio_flags_t flags)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_pin_t val; } parm1 = { .val = pin };
|
||||
union { uintptr_t x; gpio_flags_t val; } parm2 = { .val = flags };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_pin_interrupt_configure(port, pin, flags);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_pin_interrupt_configure(port, pin, flags) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE, gpio_pin_interrupt_configure, port, pin, flags); syscall__retval = gpio_pin_interrupt_configure(port, pin, flags); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE, gpio_pin_interrupt_configure, port, pin, flags, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_pin_configure(const struct device * port, gpio_pin_t pin, gpio_flags_t flags);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_pin_configure(const struct device * port, gpio_pin_t pin, gpio_flags_t flags)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_pin_t val; } parm1 = { .val = pin };
|
||||
union { uintptr_t x; gpio_flags_t val; } parm2 = { .val = flags };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_GPIO_PIN_CONFIGURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_pin_configure(port, pin, flags);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_pin_configure(port, pin, flags) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PIN_CONFIGURE, gpio_pin_configure, port, pin, flags); syscall__retval = gpio_pin_configure(port, pin, flags); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PIN_CONFIGURE, gpio_pin_configure, port, pin, flags, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_port_get_direction(const struct device * port, gpio_port_pins_t map, gpio_port_pins_t * inputs, gpio_port_pins_t * outputs);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_port_get_direction(const struct device * port, gpio_port_pins_t map, gpio_port_pins_t * inputs, gpio_port_pins_t * outputs)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = map };
|
||||
union { uintptr_t x; gpio_port_pins_t * val; } parm2 = { .val = inputs };
|
||||
union { uintptr_t x; gpio_port_pins_t * val; } parm3 = { .val = outputs };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_GPIO_PORT_GET_DIRECTION);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_port_get_direction(port, map, inputs, outputs);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_port_get_direction(port, map, inputs, outputs) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_GET_DIRECTION, gpio_port_get_direction, port, map, inputs, outputs); syscall__retval = gpio_port_get_direction(port, map, inputs, outputs); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_GET_DIRECTION, gpio_port_get_direction, port, map, inputs, outputs, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_pin_get_config(const struct device * port, gpio_pin_t pin, gpio_flags_t * flags);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_pin_get_config(const struct device * port, gpio_pin_t pin, gpio_flags_t * flags)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_pin_t val; } parm1 = { .val = pin };
|
||||
union { uintptr_t x; gpio_flags_t * val; } parm2 = { .val = flags };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_GPIO_PIN_GET_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_pin_get_config(port, pin, flags);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_pin_get_config(port, pin, flags) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PIN_GET_CONFIG, gpio_pin_get_config, port, pin, flags); syscall__retval = gpio_pin_get_config(port, pin, flags); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PIN_GET_CONFIG, gpio_pin_get_config, port, pin, flags, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_port_get_raw(const struct device * port, gpio_port_value_t * value);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_port_get_raw(const struct device * port, gpio_port_value_t * value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_port_value_t * val; } parm1 = { .val = value };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GPIO_PORT_GET_RAW);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_port_get_raw(port, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_port_get_raw(port, value) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_GET_RAW, gpio_port_get_raw, port, value); syscall__retval = gpio_port_get_raw(port, value); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_GET_RAW, gpio_port_get_raw, port, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_port_set_masked_raw(const struct device * port, gpio_port_pins_t mask, gpio_port_value_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_port_set_masked_raw(const struct device * port, gpio_port_pins_t mask, gpio_port_value_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = mask };
|
||||
union { uintptr_t x; gpio_port_value_t val; } parm2 = { .val = value };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_GPIO_PORT_SET_MASKED_RAW);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_port_set_masked_raw(port, mask, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_port_set_masked_raw(port, mask, value) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_SET_MASKED_RAW, gpio_port_set_masked_raw, port, mask, value); syscall__retval = gpio_port_set_masked_raw(port, mask, value); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_SET_MASKED_RAW, gpio_port_set_masked_raw, port, mask, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_port_set_bits_raw(const struct device * port, gpio_port_pins_t pins);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_port_set_bits_raw(const struct device * port, gpio_port_pins_t pins)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = pins };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GPIO_PORT_SET_BITS_RAW);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_port_set_bits_raw(port, pins);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_port_set_bits_raw(port, pins) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_SET_BITS_RAW, gpio_port_set_bits_raw, port, pins); syscall__retval = gpio_port_set_bits_raw(port, pins); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_SET_BITS_RAW, gpio_port_set_bits_raw, port, pins, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_port_clear_bits_raw(const struct device * port, gpio_port_pins_t pins);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_port_clear_bits_raw(const struct device * port, gpio_port_pins_t pins)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = pins };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_port_clear_bits_raw(port, pins);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_port_clear_bits_raw(port, pins) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW, gpio_port_clear_bits_raw, port, pins); syscall__retval = gpio_port_clear_bits_raw(port, pins); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW, gpio_port_clear_bits_raw, port, pins, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_port_toggle_bits(const struct device * port, gpio_port_pins_t pins);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_port_toggle_bits(const struct device * port, gpio_port_pins_t pins)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
|
||||
union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = pins };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GPIO_PORT_TOGGLE_BITS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_port_toggle_bits(port, pins);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_port_toggle_bits(port, pins) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_TOGGLE_BITS, gpio_port_toggle_bits, port, pins); syscall__retval = gpio_port_toggle_bits(port, pins); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_TOGGLE_BITS, gpio_port_toggle_bits, port, pins, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_gpio_get_pending_int(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int gpio_get_pending_int(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_GPIO_GET_PENDING_INT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_gpio_get_pending_int(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define gpio_get_pending_int(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_GPIO_GET_PENDING_INT, gpio_get_pending_int, dev); syscall__retval = gpio_get_pending_int(dev); sys_port_trace_syscall_exit(K_SYSCALL_GPIO_GET_PENDING_INT, gpio_get_pending_int, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,74 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_HAPTICS_H
|
||||
#define Z_INCLUDE_SYSCALLS_HAPTICS_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_haptics_start_output(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int haptics_start_output(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_HAPTICS_START_OUTPUT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_haptics_start_output(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define haptics_start_output(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_HAPTICS_START_OUTPUT, haptics_start_output, dev); syscall__retval = haptics_start_output(dev); sys_port_trace_syscall_exit(K_SYSCALL_HAPTICS_START_OUTPUT, haptics_start_output, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_haptics_stop_output(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int haptics_stop_output(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_HAPTICS_STOP_OUTPUT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_haptics_stop_output(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define haptics_stop_output(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_HAPTICS_STOP_OUTPUT, haptics_stop_output, dev); syscall__retval = haptics_stop_output(dev); sys_port_trace_syscall_exit(K_SYSCALL_HAPTICS_STOP_OUTPUT, haptics_stop_output, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,143 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_HWINFO_H
|
||||
#define Z_INCLUDE_SYSCALLS_HWINFO_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern ssize_t z_impl_hwinfo_get_device_id(uint8_t * buffer, size_t length);
|
||||
|
||||
__pinned_func
|
||||
static inline ssize_t hwinfo_get_device_id(uint8_t * buffer, size_t length)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; uint8_t * val; } parm0 = { .val = buffer };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = length };
|
||||
return (ssize_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_HWINFO_GET_DEVICE_ID);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_hwinfo_get_device_id(buffer, length);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define hwinfo_get_device_id(buffer, length) ({ ssize_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_GET_DEVICE_ID, hwinfo_get_device_id, buffer, length); syscall__retval = hwinfo_get_device_id(buffer, length); sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_GET_DEVICE_ID, hwinfo_get_device_id, buffer, length, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_hwinfo_get_device_eui64(uint8_t * buffer);
|
||||
|
||||
__pinned_func
|
||||
static inline int hwinfo_get_device_eui64(uint8_t * buffer)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; uint8_t * val; } parm0 = { .val = buffer };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_HWINFO_GET_DEVICE_EUI64);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_hwinfo_get_device_eui64(buffer);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define hwinfo_get_device_eui64(buffer) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_GET_DEVICE_EUI64, hwinfo_get_device_eui64, buffer); syscall__retval = hwinfo_get_device_eui64(buffer); sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_GET_DEVICE_EUI64, hwinfo_get_device_eui64, buffer, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_hwinfo_get_reset_cause(uint32_t * cause);
|
||||
|
||||
__pinned_func
|
||||
static inline int hwinfo_get_reset_cause(uint32_t * cause)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; uint32_t * val; } parm0 = { .val = cause };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_HWINFO_GET_RESET_CAUSE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_hwinfo_get_reset_cause(cause);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define hwinfo_get_reset_cause(cause) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_GET_RESET_CAUSE, hwinfo_get_reset_cause, cause); syscall__retval = hwinfo_get_reset_cause(cause); sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_GET_RESET_CAUSE, hwinfo_get_reset_cause, cause, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_hwinfo_clear_reset_cause(void);
|
||||
|
||||
__pinned_func
|
||||
static inline int hwinfo_clear_reset_cause(void)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
return (int) arch_syscall_invoke0(K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_hwinfo_clear_reset_cause();
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define hwinfo_clear_reset_cause() ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE, hwinfo_clear_reset_cause); syscall__retval = hwinfo_clear_reset_cause(); sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE, hwinfo_clear_reset_cause, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_hwinfo_get_supported_reset_cause(uint32_t * supported);
|
||||
|
||||
__pinned_func
|
||||
static inline int hwinfo_get_supported_reset_cause(uint32_t * supported)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; uint32_t * val; } parm0 = { .val = supported };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_hwinfo_get_supported_reset_cause(supported);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define hwinfo_get_supported_reset_cause(supported) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE, hwinfo_get_supported_reset_cause, supported); syscall__retval = hwinfo_get_supported_reset_cause(supported); sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE, hwinfo_get_supported_reset_cause, supported, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,171 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_I2C_H
|
||||
#define Z_INCLUDE_SYSCALLS_I2C_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_i2c_configure(const struct device * dev, uint32_t dev_config);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2c_configure(const struct device * dev, uint32_t dev_config)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = dev_config };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_I2C_CONFIGURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2c_configure(dev, dev_config);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2c_configure(dev, dev_config) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2C_CONFIGURE, i2c_configure, dev, dev_config); syscall__retval = i2c_configure(dev, dev_config); sys_port_trace_syscall_exit(K_SYSCALL_I2C_CONFIGURE, i2c_configure, dev, dev_config, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2c_get_config(const struct device * dev, uint32_t * dev_config);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2c_get_config(const struct device * dev, uint32_t * dev_config)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t * val; } parm1 = { .val = dev_config };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_I2C_GET_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2c_get_config(dev, dev_config);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2c_get_config(dev, dev_config) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2C_GET_CONFIG, i2c_get_config, dev, dev_config); syscall__retval = i2c_get_config(dev, dev_config); sys_port_trace_syscall_exit(K_SYSCALL_I2C_GET_CONFIG, i2c_get_config, dev, dev_config, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2c_transfer(const struct device * dev, struct i2c_msg * msgs, uint8_t num_msgs, uint16_t addr);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2c_transfer(const struct device * dev, struct i2c_msg * msgs, uint8_t num_msgs, uint16_t addr)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct i2c_msg * val; } parm1 = { .val = msgs };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = num_msgs };
|
||||
union { uintptr_t x; uint16_t val; } parm3 = { .val = addr };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_I2C_TRANSFER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2c_transfer(dev, msgs, num_msgs, addr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2c_transfer(dev, msgs, num_msgs, addr) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2C_TRANSFER, i2c_transfer, dev, msgs, num_msgs, addr); syscall__retval = i2c_transfer(dev, msgs, num_msgs, addr); sys_port_trace_syscall_exit(K_SYSCALL_I2C_TRANSFER, i2c_transfer, dev, msgs, num_msgs, addr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2c_recover_bus(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2c_recover_bus(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_I2C_RECOVER_BUS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2c_recover_bus(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2c_recover_bus(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2C_RECOVER_BUS, i2c_recover_bus, dev); syscall__retval = i2c_recover_bus(dev); sys_port_trace_syscall_exit(K_SYSCALL_I2C_RECOVER_BUS, i2c_recover_bus, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2c_target_driver_register(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2c_target_driver_register(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_I2C_TARGET_DRIVER_REGISTER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2c_target_driver_register(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2c_target_driver_register(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2C_TARGET_DRIVER_REGISTER, i2c_target_driver_register, dev); syscall__retval = i2c_target_driver_register(dev); sys_port_trace_syscall_exit(K_SYSCALL_I2C_TARGET_DRIVER_REGISTER, i2c_target_driver_register, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2c_target_driver_unregister(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2c_target_driver_unregister(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2c_target_driver_unregister(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2c_target_driver_unregister(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER, i2c_target_driver_unregister, dev); syscall__retval = i2c_target_driver_unregister(dev); sys_port_trace_syscall_exit(K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER, i2c_target_driver_unregister, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,128 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_I2S_H
|
||||
#define Z_INCLUDE_SYSCALLS_I2S_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_i2s_configure(const struct device * dev, enum i2s_dir dir, const struct i2s_config * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2s_configure(const struct device * dev, enum i2s_dir dir, const struct i2s_config * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum i2s_dir val; } parm1 = { .val = dir };
|
||||
union { uintptr_t x; const struct i2s_config * val; } parm2 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I2S_CONFIGURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2s_configure(dev, dir, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2s_configure(dev, dir, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2S_CONFIGURE, i2s_configure, dev, dir, cfg); syscall__retval = i2s_configure(dev, dir, cfg); sys_port_trace_syscall_exit(K_SYSCALL_I2S_CONFIGURE, i2s_configure, dev, dir, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2s_buf_read(const struct device * dev, void * buf, size_t * size);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2s_buf_read(const struct device * dev, void * buf, size_t * size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; void * val; } parm1 = { .val = buf };
|
||||
union { uintptr_t x; size_t * val; } parm2 = { .val = size };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I2S_BUF_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2s_buf_read(dev, buf, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2s_buf_read(dev, buf, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2S_BUF_READ, i2s_buf_read, dev, buf, size); syscall__retval = i2s_buf_read(dev, buf, size); sys_port_trace_syscall_exit(K_SYSCALL_I2S_BUF_READ, i2s_buf_read, dev, buf, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2s_buf_write(const struct device * dev, void * buf, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2s_buf_write(const struct device * dev, void * buf, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; void * val; } parm1 = { .val = buf };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = size };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I2S_BUF_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2s_buf_write(dev, buf, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2s_buf_write(dev, buf, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2S_BUF_WRITE, i2s_buf_write, dev, buf, size); syscall__retval = i2s_buf_write(dev, buf, size); sys_port_trace_syscall_exit(K_SYSCALL_I2S_BUF_WRITE, i2s_buf_write, dev, buf, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i2s_trigger(const struct device * dev, enum i2s_dir dir, enum i2s_trigger_cmd cmd);
|
||||
|
||||
__pinned_func
|
||||
static inline int i2s_trigger(const struct device * dev, enum i2s_dir dir, enum i2s_trigger_cmd cmd)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum i2s_dir val; } parm1 = { .val = dir };
|
||||
union { uintptr_t x; enum i2s_trigger_cmd val; } parm2 = { .val = cmd };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I2S_TRIGGER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i2s_trigger(dev, dir, cmd);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i2s_trigger(dev, dir, cmd) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I2S_TRIGGER, i2s_trigger, dev, dir, cmd); syscall__retval = i2s_trigger(dev, dir, cmd); sys_port_trace_syscall_exit(K_SYSCALL_I2S_TRIGGER, i2s_trigger, dev, dir, cmd, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,77 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_I3C_H
|
||||
#define Z_INCLUDE_SYSCALLS_I3C_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_i3c_do_ccc(const struct device * dev, struct i3c_ccc_payload * payload);
|
||||
|
||||
__pinned_func
|
||||
static inline int i3c_do_ccc(const struct device * dev, struct i3c_ccc_payload * payload)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct i3c_ccc_payload * val; } parm1 = { .val = payload };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_I3C_DO_CCC);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i3c_do_ccc(dev, payload);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i3c_do_ccc(dev, payload) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I3C_DO_CCC, i3c_do_ccc, dev, payload); syscall__retval = i3c_do_ccc(dev, payload); sys_port_trace_syscall_exit(K_SYSCALL_I3C_DO_CCC, i3c_do_ccc, dev, payload, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_i3c_transfer(struct i3c_device_desc * target, struct i3c_msg * msgs, uint8_t num_msgs);
|
||||
|
||||
__pinned_func
|
||||
static inline int i3c_transfer(struct i3c_device_desc * target, struct i3c_msg * msgs, uint8_t num_msgs)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct i3c_device_desc * val; } parm0 = { .val = target };
|
||||
union { uintptr_t x; struct i3c_msg * val; } parm1 = { .val = msgs };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = num_msgs };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I3C_TRANSFER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_i3c_transfer(target, msgs, num_msgs);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define i3c_transfer(target, msgs, num_msgs) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_I3C_TRANSFER, i3c_transfer, target, msgs, num_msgs); syscall__retval = i3c_transfer(target, msgs, num_msgs); sys_port_trace_syscall_exit(K_SYSCALL_I3C_TRANSFER, i3c_transfer, target, msgs, num_msgs, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,52 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_INPUT_RENESAS_RA_CTSU_H
|
||||
#define Z_INCLUDE_SYSCALLS_INPUT_RENESAS_RA_CTSU_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_renesas_ra_ctsu_group_configure(const struct device * dev, const struct renesas_ra_ctsu_touch_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int renesas_ra_ctsu_group_configure(const struct device * dev, const struct renesas_ra_ctsu_touch_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct renesas_ra_ctsu_touch_cfg * val; } parm1 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RENESAS_RA_CTSU_GROUP_CONFIGURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_renesas_ra_ctsu_group_configure(dev, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define renesas_ra_ctsu_group_configure(dev, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RENESAS_RA_CTSU_GROUP_CONFIGURE, renesas_ra_ctsu_group_configure, dev, cfg); syscall__retval = renesas_ra_ctsu_group_configure(dev, cfg); sys_port_trace_syscall_exit(K_SYSCALL_RENESAS_RA_CTSU_GROUP_CONFIGURE, renesas_ra_ctsu_group_configure, dev, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,52 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_INPUT_RENESAS_RX_CTSU_H
|
||||
#define Z_INCLUDE_SYSCALLS_INPUT_RENESAS_RX_CTSU_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_renesas_rx_ctsu_group_configure(const struct device * dev, const struct renesas_rx_ctsu_touch_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int renesas_rx_ctsu_group_configure(const struct device * dev, const struct renesas_rx_ctsu_touch_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct renesas_rx_ctsu_touch_cfg * val; } parm1 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RENESAS_RX_CTSU_GROUP_CONFIGURE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_renesas_rx_ctsu_group_configure(dev, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define renesas_rx_ctsu_group_configure(dev, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RENESAS_RX_CTSU_GROUP_CONFIGURE, renesas_rx_ctsu_group_configure, dev, cfg); syscall__retval = renesas_rx_ctsu_group_configure(dev, cfg); sys_port_trace_syscall_exit(K_SYSCALL_RENESAS_RX_CTSU_GROUP_CONFIGURE, renesas_rx_ctsu_group_configure, dev, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,149 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_IPM_H
|
||||
#define Z_INCLUDE_SYSCALLS_IPM_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_ipm_send(const struct device * ipmdev, int wait, uint32_t id, const void * data, int size);
|
||||
|
||||
__pinned_func
|
||||
static inline int ipm_send(const struct device * ipmdev, int wait, uint32_t id, const void * data, int size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
|
||||
union { uintptr_t x; int val; } parm1 = { .val = wait };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = id };
|
||||
union { uintptr_t x; const void * val; } parm3 = { .val = data };
|
||||
union { uintptr_t x; int val; } parm4 = { .val = size };
|
||||
return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_IPM_SEND);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ipm_send(ipmdev, wait, id, data, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ipm_send(ipmdev, wait, id, data, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IPM_SEND, ipm_send, ipmdev, wait, id, data, size); syscall__retval = ipm_send(ipmdev, wait, id, data, size); sys_port_trace_syscall_exit(K_SYSCALL_IPM_SEND, ipm_send, ipmdev, wait, id, data, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ipm_max_data_size_get(const struct device * ipmdev);
|
||||
|
||||
__pinned_func
|
||||
static inline int ipm_max_data_size_get(const struct device * ipmdev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_IPM_MAX_DATA_SIZE_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ipm_max_data_size_get(ipmdev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ipm_max_data_size_get(ipmdev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IPM_MAX_DATA_SIZE_GET, ipm_max_data_size_get, ipmdev); syscall__retval = ipm_max_data_size_get(ipmdev); sys_port_trace_syscall_exit(K_SYSCALL_IPM_MAX_DATA_SIZE_GET, ipm_max_data_size_get, ipmdev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_ipm_max_id_val_get(const struct device * ipmdev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t ipm_max_id_val_get(const struct device * ipmdev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IPM_MAX_ID_VAL_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ipm_max_id_val_get(ipmdev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ipm_max_id_val_get(ipmdev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IPM_MAX_ID_VAL_GET, ipm_max_id_val_get, ipmdev); syscall__retval = ipm_max_id_val_get(ipmdev); sys_port_trace_syscall_exit(K_SYSCALL_IPM_MAX_ID_VAL_GET, ipm_max_id_val_get, ipmdev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ipm_set_enabled(const struct device * ipmdev, int enable);
|
||||
|
||||
__pinned_func
|
||||
static inline int ipm_set_enabled(const struct device * ipmdev, int enable)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
|
||||
union { uintptr_t x; int val; } parm1 = { .val = enable };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IPM_SET_ENABLED);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ipm_set_enabled(ipmdev, enable);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ipm_set_enabled(ipmdev, enable) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IPM_SET_ENABLED, ipm_set_enabled, ipmdev, enable); syscall__retval = ipm_set_enabled(ipmdev, enable); sys_port_trace_syscall_exit(K_SYSCALL_IPM_SET_ENABLED, ipm_set_enabled, ipmdev, enable, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_ipm_complete(const struct device * ipmdev);
|
||||
|
||||
__pinned_func
|
||||
static inline void ipm_complete(const struct device * ipmdev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_IPM_COMPLETE);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_ipm_complete(ipmdev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ipm_complete(ipmdev) do { sys_port_trace_syscall_enter(K_SYSCALL_IPM_COMPLETE, ipm_complete, ipmdev); ipm_complete(ipmdev); sys_port_trace_syscall_exit(K_SYSCALL_IPM_COMPLETE, ipm_complete, ipmdev); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,315 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_IVSHMEM_H
|
||||
#define Z_INCLUDE_SYSCALLS_IVSHMEM_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern size_t z_impl_ivshmem_get_mem(const struct device * dev, uintptr_t * memmap);
|
||||
|
||||
__pinned_func
|
||||
static inline size_t ivshmem_get_mem(const struct device * dev, uintptr_t * memmap)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uintptr_t * val; } parm1 = { .val = memmap };
|
||||
return (size_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_GET_MEM);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_mem(dev, memmap);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_mem(dev, memmap) ({ size_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_MEM, ivshmem_get_mem, dev, memmap); syscall__retval = ivshmem_get_mem(dev, memmap); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_MEM, ivshmem_get_mem, dev, memmap, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_ivshmem_get_id(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t ivshmem_get_id(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IVSHMEM_GET_ID);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_id(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_id(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_ID, ivshmem_get_id, dev); syscall__retval = ivshmem_get_id(dev); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_ID, ivshmem_get_id, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint16_t z_impl_ivshmem_get_vectors(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint16_t ivshmem_get_vectors(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint16_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IVSHMEM_GET_VECTORS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_vectors(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_vectors(dev) ({ uint16_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_VECTORS, ivshmem_get_vectors, dev); syscall__retval = ivshmem_get_vectors(dev); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_VECTORS, ivshmem_get_vectors, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ivshmem_int_peer(const struct device * dev, uint32_t peer_id, uint16_t vector);
|
||||
|
||||
__pinned_func
|
||||
static inline int ivshmem_int_peer(const struct device * dev, uint32_t peer_id, uint16_t vector)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = peer_id };
|
||||
union { uintptr_t x; uint16_t val; } parm2 = { .val = vector };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_IVSHMEM_INT_PEER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_int_peer(dev, peer_id, vector);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_int_peer(dev, peer_id, vector) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_INT_PEER, ivshmem_int_peer, dev, peer_id, vector); syscall__retval = ivshmem_int_peer(dev, peer_id, vector); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_INT_PEER, ivshmem_int_peer, dev, peer_id, vector, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ivshmem_register_handler(const struct device * dev, struct k_poll_signal * signal, uint16_t vector);
|
||||
|
||||
__pinned_func
|
||||
static inline int ivshmem_register_handler(const struct device * dev, struct k_poll_signal * signal, uint16_t vector)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct k_poll_signal * val; } parm1 = { .val = signal };
|
||||
union { uintptr_t x; uint16_t val; } parm2 = { .val = vector };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_IVSHMEM_REGISTER_HANDLER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_register_handler(dev, signal, vector);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_register_handler(dev, signal, vector) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_REGISTER_HANDLER, ivshmem_register_handler, dev, signal, vector); syscall__retval = ivshmem_register_handler(dev, signal, vector); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_REGISTER_HANDLER, ivshmem_register_handler, dev, signal, vector, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern size_t z_impl_ivshmem_get_rw_mem_section(const struct device * dev, uintptr_t * memmap);
|
||||
|
||||
__pinned_func
|
||||
static inline size_t ivshmem_get_rw_mem_section(const struct device * dev, uintptr_t * memmap)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uintptr_t * val; } parm1 = { .val = memmap };
|
||||
return (size_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_rw_mem_section(dev, memmap);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_rw_mem_section(dev, memmap) ({ size_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION, ivshmem_get_rw_mem_section, dev, memmap); syscall__retval = ivshmem_get_rw_mem_section(dev, memmap); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION, ivshmem_get_rw_mem_section, dev, memmap, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern size_t z_impl_ivshmem_get_output_mem_section(const struct device * dev, uint32_t peer_id, uintptr_t * memmap);
|
||||
|
||||
__pinned_func
|
||||
static inline size_t ivshmem_get_output_mem_section(const struct device * dev, uint32_t peer_id, uintptr_t * memmap)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = peer_id };
|
||||
union { uintptr_t x; uintptr_t * val; } parm2 = { .val = memmap };
|
||||
return (size_t) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_output_mem_section(dev, peer_id, memmap);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_output_mem_section(dev, peer_id, memmap) ({ size_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION, ivshmem_get_output_mem_section, dev, peer_id, memmap); syscall__retval = ivshmem_get_output_mem_section(dev, peer_id, memmap); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION, ivshmem_get_output_mem_section, dev, peer_id, memmap, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_ivshmem_get_state(const struct device * dev, uint32_t peer_id);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t ivshmem_get_state(const struct device * dev, uint32_t peer_id)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = peer_id };
|
||||
return (uint32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_GET_STATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_state(dev, peer_id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_state(dev, peer_id) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_STATE, ivshmem_get_state, dev, peer_id); syscall__retval = ivshmem_get_state(dev, peer_id); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_STATE, ivshmem_get_state, dev, peer_id, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ivshmem_set_state(const struct device * dev, uint32_t state);
|
||||
|
||||
__pinned_func
|
||||
static inline int ivshmem_set_state(const struct device * dev, uint32_t state)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = state };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_SET_STATE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_set_state(dev, state);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_set_state(dev, state) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_SET_STATE, ivshmem_set_state, dev, state); syscall__retval = ivshmem_set_state(dev, state); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_SET_STATE, ivshmem_set_state, dev, state, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_ivshmem_get_max_peers(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t ivshmem_get_max_peers(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IVSHMEM_GET_MAX_PEERS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_max_peers(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_max_peers(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_MAX_PEERS, ivshmem_get_max_peers, dev); syscall__retval = ivshmem_get_max_peers(dev); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_MAX_PEERS, ivshmem_get_max_peers, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint16_t z_impl_ivshmem_get_protocol(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint16_t ivshmem_get_protocol(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint16_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IVSHMEM_GET_PROTOCOL);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_get_protocol(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_get_protocol(dev) ({ uint16_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_PROTOCOL, ivshmem_get_protocol, dev); syscall__retval = ivshmem_get_protocol(dev); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_PROTOCOL, ivshmem_get_protocol, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ivshmem_enable_interrupts(const struct device * dev, bool enable);
|
||||
|
||||
__pinned_func
|
||||
static inline int ivshmem_enable_interrupts(const struct device * dev, bool enable)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; bool val; } parm1 = { .val = enable };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ivshmem_enable_interrupts(dev, enable);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ivshmem_enable_interrupts(dev, enable) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS, ivshmem_enable_interrupts, dev, enable); syscall__retval = ivshmem_enable_interrupts(dev, enable); sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS, ivshmem_enable_interrupts, dev, enable, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,124 @@
|
||||
/* 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 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 */
|
||||
@@ -0,0 +1,229 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_LED_H
|
||||
#define Z_INCLUDE_SYSCALLS_LED_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_led_blink(const struct device * dev, uint32_t led, uint32_t delay_on, uint32_t delay_off);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_blink(const struct device * dev, uint32_t led, uint32_t delay_on, uint32_t delay_off)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = delay_on };
|
||||
union { uintptr_t x; uint32_t val; } parm3 = { .val = delay_off };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_LED_BLINK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_blink(dev, led, delay_on, delay_off);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_blink(dev, led, delay_on, delay_off) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_BLINK, led_blink, dev, led, delay_on, delay_off); syscall__retval = led_blink(dev, led, delay_on, delay_off); sys_port_trace_syscall_exit(K_SYSCALL_LED_BLINK, led_blink, dev, led, delay_on, delay_off, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_led_get_info(const struct device * dev, uint32_t led, const struct led_info ** info);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_get_info(const struct device * dev, uint32_t led, const struct led_info ** info)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
|
||||
union { uintptr_t x; const struct led_info ** val; } parm2 = { .val = info };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_LED_GET_INFO);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_get_info(dev, led, info);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_get_info(dev, led, info) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_GET_INFO, led_get_info, dev, led, info); syscall__retval = led_get_info(dev, led, info); sys_port_trace_syscall_exit(K_SYSCALL_LED_GET_INFO, led_get_info, dev, led, info, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_led_set_brightness(const struct device * dev, uint32_t led, uint8_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_set_brightness(const struct device * dev, uint32_t led, uint8_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = value };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_LED_SET_BRIGHTNESS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_set_brightness(dev, led, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_set_brightness(dev, led, value) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_SET_BRIGHTNESS, led_set_brightness, dev, led, value); syscall__retval = led_set_brightness(dev, led, value); sys_port_trace_syscall_exit(K_SYSCALL_LED_SET_BRIGHTNESS, led_set_brightness, dev, led, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_led_write_channels(const struct device * dev, uint32_t start_channel, uint32_t num_channels, const uint8_t * buf);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_write_channels(const struct device * dev, uint32_t start_channel, uint32_t num_channels, const uint8_t * buf)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = start_channel };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = num_channels };
|
||||
union { uintptr_t x; const uint8_t * val; } parm3 = { .val = buf };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_LED_WRITE_CHANNELS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_write_channels(dev, start_channel, num_channels, buf);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_write_channels(dev, start_channel, num_channels, buf) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_WRITE_CHANNELS, led_write_channels, dev, start_channel, num_channels, buf); syscall__retval = led_write_channels(dev, start_channel, num_channels, buf); sys_port_trace_syscall_exit(K_SYSCALL_LED_WRITE_CHANNELS, led_write_channels, dev, start_channel, num_channels, buf, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_led_set_channel(const struct device * dev, uint32_t channel, uint8_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_set_channel(const struct device * dev, uint32_t channel, uint8_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = value };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_LED_SET_CHANNEL);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_set_channel(dev, channel, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_set_channel(dev, channel, value) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_SET_CHANNEL, led_set_channel, dev, channel, value); syscall__retval = led_set_channel(dev, channel, value); sys_port_trace_syscall_exit(K_SYSCALL_LED_SET_CHANNEL, led_set_channel, dev, channel, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_led_set_color(const struct device * dev, uint32_t led, uint8_t num_colors, const uint8_t * color);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_set_color(const struct device * dev, uint32_t led, uint8_t num_colors, const uint8_t * color)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
|
||||
union { uintptr_t x; uint8_t val; } parm2 = { .val = num_colors };
|
||||
union { uintptr_t x; const uint8_t * val; } parm3 = { .val = color };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_LED_SET_COLOR);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_set_color(dev, led, num_colors, color);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_set_color(dev, led, num_colors, color) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_SET_COLOR, led_set_color, dev, led, num_colors, color); syscall__retval = led_set_color(dev, led, num_colors, color); sys_port_trace_syscall_exit(K_SYSCALL_LED_SET_COLOR, led_set_color, dev, led, num_colors, color, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_led_on(const struct device * dev, uint32_t led);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_on(const struct device * dev, uint32_t led)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_LED_ON);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_on(dev, led);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_on(dev, led) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_ON, led_on, dev, led); syscall__retval = led_on(dev, led); sys_port_trace_syscall_exit(K_SYSCALL_LED_ON, led_on, dev, led, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_led_off(const struct device * dev, uint32_t led);
|
||||
|
||||
__pinned_func
|
||||
static inline int led_off(const struct device * dev, uint32_t led)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_LED_OFF);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_led_off(dev, led);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define led_off(dev, led) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LED_OFF, led_off, dev, led); syscall__retval = led_off(dev, led); sys_port_trace_syscall_exit(K_SYSCALL_LED_OFF, led_off, dev, led, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,126 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_LIBC_HOOKS_H
|
||||
#define Z_INCLUDE_SYSCALLS_LIBC_HOOKS_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_zephyr_read_stdin(char * buf, int nbytes);
|
||||
|
||||
__pinned_func
|
||||
static inline int zephyr_read_stdin(char * buf, int nbytes)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; char * val; } parm0 = { .val = buf };
|
||||
union { uintptr_t x; int val; } parm1 = { .val = nbytes };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ZEPHYR_READ_STDIN);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_zephyr_read_stdin(buf, nbytes);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define zephyr_read_stdin(buf, nbytes) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ZEPHYR_READ_STDIN, zephyr_read_stdin, buf, nbytes); syscall__retval = zephyr_read_stdin(buf, nbytes); sys_port_trace_syscall_exit(K_SYSCALL_ZEPHYR_READ_STDIN, zephyr_read_stdin, buf, nbytes, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_zephyr_write_stdout(const void * buf, int nbytes);
|
||||
|
||||
__pinned_func
|
||||
static inline int zephyr_write_stdout(const void * buf, int nbytes)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void * val; } parm0 = { .val = buf };
|
||||
union { uintptr_t x; int val; } parm1 = { .val = nbytes };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ZEPHYR_WRITE_STDOUT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_zephyr_write_stdout(buf, nbytes);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define zephyr_write_stdout(buf, nbytes) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ZEPHYR_WRITE_STDOUT, zephyr_write_stdout, buf, nbytes); syscall__retval = zephyr_write_stdout(buf, nbytes); sys_port_trace_syscall_exit(K_SYSCALL_ZEPHYR_WRITE_STDOUT, zephyr_write_stdout, buf, nbytes, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_zephyr_fputc(int c, FILE * stream);
|
||||
|
||||
__pinned_func
|
||||
static inline int zephyr_fputc(int c, FILE * stream)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int val; } parm0 = { .val = c };
|
||||
union { uintptr_t x; FILE * val; } parm1 = { .val = stream };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ZEPHYR_FPUTC);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_zephyr_fputc(c, stream);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define zephyr_fputc(c, stream) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ZEPHYR_FPUTC, zephyr_fputc, c, stream); syscall__retval = zephyr_fputc(c, stream); sys_port_trace_syscall_exit(K_SYSCALL_ZEPHYR_FPUTC, zephyr_fputc, c, stream, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern size_t z_impl_zephyr_fwrite(const void *ZRESTRICT ptr, size_t size, size_t nitems, FILE *ZRESTRICT stream);
|
||||
|
||||
__pinned_func
|
||||
static inline size_t zephyr_fwrite(const void *ZRESTRICT ptr, size_t size, size_t nitems, FILE *ZRESTRICT stream)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void *ZRESTRICT val; } parm0 = { .val = ptr };
|
||||
union { uintptr_t x; size_t val; } parm1 = { .val = size };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = nitems };
|
||||
union { uintptr_t x; FILE *ZRESTRICT val; } parm3 = { .val = stream };
|
||||
return (size_t) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_ZEPHYR_FWRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_zephyr_fwrite(ptr, size, nitems, stream);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define zephyr_fwrite(ptr, size, nitems, stream) ({ size_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_ZEPHYR_FWRITE, zephyr_fwrite, ptr, size, nitems, stream); syscall__retval = zephyr_fwrite(ptr, size, nitems, stream); sys_port_trace_syscall_exit(K_SYSCALL_ZEPHYR_FWRITE, zephyr_fwrite, ptr, size, nitems, stream, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,54 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_LLEXT_H
|
||||
#define Z_INCLUDE_SYSCALLS_LLEXT_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern ssize_t z_impl_llext_get_fn_table(struct llext * ext, bool is_init, void * buf, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline ssize_t llext_get_fn_table(struct llext * ext, bool is_init, void * buf, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct llext * val; } parm0 = { .val = ext };
|
||||
union { uintptr_t x; bool val; } parm1 = { .val = is_init };
|
||||
union { uintptr_t x; void * val; } parm2 = { .val = buf };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = size };
|
||||
return (ssize_t) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_LLEXT_GET_FN_TABLE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_llext_get_fn_table(ext, is_init, buf, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define llext_get_fn_table(ext, is_init, buf, size) ({ ssize_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LLEXT_GET_FN_TABLE, llext_get_fn_table, ext, is_init, buf, size); syscall__retval = llext_get_fn_table(ext, is_init, buf, size); sys_port_trace_syscall_exit(K_SYSCALL_LLEXT_GET_FN_TABLE, llext_get_fn_table, ext, is_init, buf, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,145 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_LOG_CTRL_H
|
||||
#define Z_INCLUDE_SYSCALLS_LOG_CTRL_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_log_panic(void);
|
||||
|
||||
__pinned_func
|
||||
static inline void log_panic(void)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
(void) arch_syscall_invoke0(K_SYSCALL_LOG_PANIC);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_log_panic();
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define log_panic() do { sys_port_trace_syscall_enter(K_SYSCALL_LOG_PANIC, log_panic); log_panic(); sys_port_trace_syscall_exit(K_SYSCALL_LOG_PANIC, log_panic); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_log_process(void);
|
||||
|
||||
__pinned_func
|
||||
static inline bool log_process(void)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
return (bool) arch_syscall_invoke0(K_SYSCALL_LOG_PROCESS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_log_process();
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define log_process() ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LOG_PROCESS, log_process); syscall__retval = log_process(); sys_port_trace_syscall_exit(K_SYSCALL_LOG_PROCESS, log_process, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_log_buffered_cnt(void);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t log_buffered_cnt(void)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
return (uint32_t) arch_syscall_invoke0(K_SYSCALL_LOG_BUFFERED_CNT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_log_buffered_cnt();
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define log_buffered_cnt() ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LOG_BUFFERED_CNT, log_buffered_cnt); syscall__retval = log_buffered_cnt(); sys_port_trace_syscall_exit(K_SYSCALL_LOG_BUFFERED_CNT, log_buffered_cnt, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_log_filter_set(struct log_backend const *const backend, uint32_t domain_id, int16_t source_id, uint32_t level);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t log_filter_set(struct log_backend const *const backend, uint32_t domain_id, int16_t source_id, uint32_t level)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct log_backend const *const val; } parm0 = { .val = backend };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = domain_id };
|
||||
union { uintptr_t x; int16_t val; } parm2 = { .val = source_id };
|
||||
union { uintptr_t x; uint32_t val; } parm3 = { .val = level };
|
||||
return (uint32_t) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_LOG_FILTER_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_log_filter_set(backend, domain_id, source_id, level);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define log_filter_set(backend, domain_id, source_id, level) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LOG_FILTER_SET, log_filter_set, backend, domain_id, source_id, level); syscall__retval = log_filter_set(backend, domain_id, source_id, level); sys_port_trace_syscall_exit(K_SYSCALL_LOG_FILTER_SET, log_filter_set, backend, domain_id, source_id, level, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_log_frontend_filter_set(int16_t source_id, uint32_t level);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t log_frontend_filter_set(int16_t source_id, uint32_t level)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; int16_t val; } parm0 = { .val = source_id };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = level };
|
||||
return (uint32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_LOG_FRONTEND_FILTER_SET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_log_frontend_filter_set(source_id, level);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define log_frontend_filter_set(source_id, level) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_LOG_FRONTEND_FILTER_SET, log_frontend_filter_set, source_id, level); syscall__retval = log_frontend_filter_set(source_id, level); sys_port_trace_syscall_exit(K_SYSCALL_LOG_FRONTEND_FILTER_SET, log_frontend_filter_set, source_id, level, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,136 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_LOG_MSG_H
|
||||
#define Z_INCLUDE_SYSCALLS_LOG_MSG_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_z_log_msg_simple_create_0(const void * source, uint32_t level, const char * fmt);
|
||||
|
||||
__pinned_func
|
||||
static inline void z_log_msg_simple_create_0(const void * source, uint32_t level, const char * fmt)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void * val; } parm0 = { .val = source };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = level };
|
||||
union { uintptr_t x; const char * val; } parm2 = { .val = fmt };
|
||||
(void) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_z_log_msg_simple_create_0(source, level, fmt);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define z_log_msg_simple_create_0(source, level, fmt) do { sys_port_trace_syscall_enter(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0, z_log_msg_simple_create_0, source, level, fmt); z_log_msg_simple_create_0(source, level, fmt); sys_port_trace_syscall_exit(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0, z_log_msg_simple_create_0, source, level, fmt); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_z_log_msg_simple_create_1(const void * source, uint32_t level, const char * fmt, uint32_t arg);
|
||||
|
||||
__pinned_func
|
||||
static inline void z_log_msg_simple_create_1(const void * source, uint32_t level, const char * fmt, uint32_t arg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void * val; } parm0 = { .val = source };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = level };
|
||||
union { uintptr_t x; const char * val; } parm2 = { .val = fmt };
|
||||
union { uintptr_t x; uint32_t val; } parm3 = { .val = arg };
|
||||
(void) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_z_log_msg_simple_create_1(source, level, fmt, arg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define z_log_msg_simple_create_1(source, level, fmt, arg) do { sys_port_trace_syscall_enter(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1, z_log_msg_simple_create_1, source, level, fmt, arg); z_log_msg_simple_create_1(source, level, fmt, arg); sys_port_trace_syscall_exit(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1, z_log_msg_simple_create_1, source, level, fmt, arg); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_z_log_msg_simple_create_2(const void * source, uint32_t level, const char * fmt, uint32_t arg0, uint32_t arg1);
|
||||
|
||||
__pinned_func
|
||||
static inline void z_log_msg_simple_create_2(const void * source, uint32_t level, const char * fmt, uint32_t arg0, uint32_t arg1)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void * val; } parm0 = { .val = source };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = level };
|
||||
union { uintptr_t x; const char * val; } parm2 = { .val = fmt };
|
||||
union { uintptr_t x; uint32_t val; } parm3 = { .val = arg0 };
|
||||
union { uintptr_t x; uint32_t val; } parm4 = { .val = arg1 };
|
||||
(void) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_z_log_msg_simple_create_2(source, level, fmt, arg0, arg1);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define z_log_msg_simple_create_2(source, level, fmt, arg0, arg1) do { sys_port_trace_syscall_enter(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2, z_log_msg_simple_create_2, source, level, fmt, arg0, arg1); z_log_msg_simple_create_2(source, level, fmt, arg0, arg1); sys_port_trace_syscall_exit(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2, z_log_msg_simple_create_2, source, level, fmt, arg0, arg1); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_z_log_msg_static_create(const void * source, const struct log_msg_desc desc, uint8_t * package, const void * data);
|
||||
|
||||
__pinned_func
|
||||
static inline void z_log_msg_static_create(const void * source, const struct log_msg_desc desc, uint8_t * package, const void * data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const void * val; } parm0 = { .val = source };
|
||||
union { uintptr_t x; const struct log_msg_desc val; } parm1 = { .val = desc };
|
||||
union { uintptr_t x; uint8_t * val; } parm2 = { .val = package };
|
||||
union { uintptr_t x; const void * val; } parm3 = { .val = data };
|
||||
(void) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_Z_LOG_MSG_STATIC_CREATE);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_z_log_msg_static_create(source, desc, package, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define z_log_msg_static_create(source, desc, package, data) do { sys_port_trace_syscall_enter(K_SYSCALL_Z_LOG_MSG_STATIC_CREATE, z_log_msg_static_create, source, desc, package, data); z_log_msg_static_create(source, desc, package, data); sys_port_trace_syscall_exit(K_SYSCALL_Z_LOG_MSG_STATIC_CREATE, z_log_msg_static_create, source, desc, package, data); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,76 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_MAXIM_DS3231_H
|
||||
#define Z_INCLUDE_SYSCALLS_MAXIM_DS3231_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_maxim_ds3231_req_syncpoint(const struct device * dev, struct k_poll_signal * signal);
|
||||
|
||||
__pinned_func
|
||||
static inline int maxim_ds3231_req_syncpoint(const struct device * dev, struct k_poll_signal * signal)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct k_poll_signal * val; } parm1 = { .val = signal };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_maxim_ds3231_req_syncpoint(dev, signal);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define maxim_ds3231_req_syncpoint(dev, signal) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT, maxim_ds3231_req_syncpoint, dev, signal); syscall__retval = maxim_ds3231_req_syncpoint(dev, signal); sys_port_trace_syscall_exit(K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT, maxim_ds3231_req_syncpoint, dev, signal, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_maxim_ds3231_get_syncpoint(const struct device * dev, struct maxim_ds3231_syncpoint * syncpoint);
|
||||
|
||||
__pinned_func
|
||||
static inline int maxim_ds3231_get_syncpoint(const struct device * dev, struct maxim_ds3231_syncpoint * syncpoint)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct maxim_ds3231_syncpoint * val; } parm1 = { .val = syncpoint };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_maxim_ds3231_get_syncpoint(dev, syncpoint);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define maxim_ds3231_get_syncpoint(dev, syncpoint) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT, maxim_ds3231_get_syncpoint, dev, syncpoint); syscall__retval = maxim_ds3231_get_syncpoint(dev, syncpoint); sys_port_trace_syscall_exit(K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT, maxim_ds3231_get_syncpoint, dev, syncpoint, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,124 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_MBOX_H
|
||||
#define Z_INCLUDE_SYSCALLS_MBOX_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_mbox_send(const struct device * dev, mbox_channel_id_t channel_id, const struct mbox_msg * msg);
|
||||
|
||||
__pinned_func
|
||||
static inline int mbox_send(const struct device * dev, mbox_channel_id_t channel_id, const struct mbox_msg * msg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; mbox_channel_id_t val; } parm1 = { .val = channel_id };
|
||||
union { uintptr_t x; const struct mbox_msg * val; } parm2 = { .val = msg };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_MBOX_SEND);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mbox_send(dev, channel_id, msg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mbox_send(dev, channel_id, msg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MBOX_SEND, mbox_send, dev, channel_id, msg); syscall__retval = mbox_send(dev, channel_id, msg); sys_port_trace_syscall_exit(K_SYSCALL_MBOX_SEND, mbox_send, dev, channel_id, msg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mbox_mtu_get(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int mbox_mtu_get(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_MBOX_MTU_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mbox_mtu_get(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mbox_mtu_get(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MBOX_MTU_GET, mbox_mtu_get, dev); syscall__retval = mbox_mtu_get(dev); sys_port_trace_syscall_exit(K_SYSCALL_MBOX_MTU_GET, mbox_mtu_get, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mbox_set_enabled(const struct device * dev, mbox_channel_id_t channel_id, bool enabled);
|
||||
|
||||
__pinned_func
|
||||
static inline int mbox_set_enabled(const struct device * dev, mbox_channel_id_t channel_id, bool enabled)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; mbox_channel_id_t val; } parm1 = { .val = channel_id };
|
||||
union { uintptr_t x; bool val; } parm2 = { .val = enabled };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_MBOX_SET_ENABLED);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mbox_set_enabled(dev, channel_id, enabled);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mbox_set_enabled(dev, channel_id, enabled) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MBOX_SET_ENABLED, mbox_set_enabled, dev, channel_id, enabled); syscall__retval = mbox_set_enabled(dev, channel_id, enabled); sys_port_trace_syscall_exit(K_SYSCALL_MBOX_SET_ENABLED, mbox_set_enabled, dev, channel_id, enabled, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern uint32_t z_impl_mbox_max_channels_get(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline uint32_t mbox_max_channels_get(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_MBOX_MAX_CHANNELS_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mbox_max_channels_get(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mbox_max_channels_get(dev) ({ uint32_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MBOX_MAX_CHANNELS_GET, mbox_max_channels_get, dev); syscall__retval = mbox_max_channels_get(dev); sys_port_trace_syscall_exit(K_SYSCALL_MBOX_MAX_CHANNELS_GET, mbox_max_channels_get, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,182 @@
|
||||
/* 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 void z_impl_mdio_bus_enable(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline void mdio_bus_enable(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_MDIO_BUS_ENABLE);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_mdio_bus_enable(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mdio_bus_enable(dev) do { sys_port_trace_syscall_enter(K_SYSCALL_MDIO_BUS_ENABLE, mdio_bus_enable, dev); mdio_bus_enable(dev); sys_port_trace_syscall_exit(K_SYSCALL_MDIO_BUS_ENABLE, mdio_bus_enable, dev); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_mdio_bus_disable(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline void mdio_bus_disable(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_MDIO_BUS_DISABLE);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_mdio_bus_disable(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mdio_bus_disable(dev) do { sys_port_trace_syscall_enter(K_SYSCALL_MDIO_BUS_DISABLE, mdio_bus_disable, dev); mdio_bus_disable(dev); sys_port_trace_syscall_exit(K_SYSCALL_MDIO_BUS_DISABLE, mdio_bus_disable, dev); } while(false)
|
||||
#endif
|
||||
#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 */
|
||||
@@ -0,0 +1,202 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_MSPI_H
|
||||
#define Z_INCLUDE_SYSCALLS_MSPI_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_mspi_config(const struct mspi_dt_spec * spec);
|
||||
|
||||
__pinned_func
|
||||
static inline int mspi_config(const struct mspi_dt_spec * spec)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct mspi_dt_spec * val; } parm0 = { .val = spec };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_MSPI_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mspi_config(spec);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mspi_config(spec) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MSPI_CONFIG, mspi_config, spec); syscall__retval = mspi_config(spec); sys_port_trace_syscall_exit(K_SYSCALL_MSPI_CONFIG, mspi_config, spec, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mspi_dev_config(const struct device * controller, const struct mspi_dev_id * dev_id, const enum mspi_dev_cfg_mask param_mask, const struct mspi_dev_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int mspi_dev_config(const struct device * controller, const struct mspi_dev_id * dev_id, const enum mspi_dev_cfg_mask param_mask, const struct mspi_dev_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = controller };
|
||||
union { uintptr_t x; const struct mspi_dev_id * val; } parm1 = { .val = dev_id };
|
||||
union { uintptr_t x; const enum mspi_dev_cfg_mask val; } parm2 = { .val = param_mask };
|
||||
union { uintptr_t x; const struct mspi_dev_cfg * val; } parm3 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_MSPI_DEV_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mspi_dev_config(controller, dev_id, param_mask, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mspi_dev_config(controller, dev_id, param_mask, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MSPI_DEV_CONFIG, mspi_dev_config, controller, dev_id, param_mask, cfg); syscall__retval = mspi_dev_config(controller, dev_id, param_mask, cfg); sys_port_trace_syscall_exit(K_SYSCALL_MSPI_DEV_CONFIG, mspi_dev_config, controller, dev_id, param_mask, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mspi_get_channel_status(const struct device * controller, uint8_t ch);
|
||||
|
||||
__pinned_func
|
||||
static inline int mspi_get_channel_status(const struct device * controller, uint8_t ch)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = controller };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = ch };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_MSPI_GET_CHANNEL_STATUS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mspi_get_channel_status(controller, ch);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mspi_get_channel_status(controller, ch) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MSPI_GET_CHANNEL_STATUS, mspi_get_channel_status, controller, ch); syscall__retval = mspi_get_channel_status(controller, ch); sys_port_trace_syscall_exit(K_SYSCALL_MSPI_GET_CHANNEL_STATUS, mspi_get_channel_status, controller, ch, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mspi_transceive(const struct device * controller, const struct mspi_dev_id * dev_id, const struct mspi_xfer * req);
|
||||
|
||||
__pinned_func
|
||||
static inline int mspi_transceive(const struct device * controller, const struct mspi_dev_id * dev_id, const struct mspi_xfer * req)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = controller };
|
||||
union { uintptr_t x; const struct mspi_dev_id * val; } parm1 = { .val = dev_id };
|
||||
union { uintptr_t x; const struct mspi_xfer * val; } parm2 = { .val = req };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_MSPI_TRANSCEIVE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mspi_transceive(controller, dev_id, req);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mspi_transceive(controller, dev_id, req) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MSPI_TRANSCEIVE, mspi_transceive, controller, dev_id, req); syscall__retval = mspi_transceive(controller, dev_id, req); sys_port_trace_syscall_exit(K_SYSCALL_MSPI_TRANSCEIVE, mspi_transceive, controller, dev_id, req, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mspi_xip_config(const struct device * controller, const struct mspi_dev_id * dev_id, const struct mspi_xip_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int mspi_xip_config(const struct device * controller, const struct mspi_dev_id * dev_id, const struct mspi_xip_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = controller };
|
||||
union { uintptr_t x; const struct mspi_dev_id * val; } parm1 = { .val = dev_id };
|
||||
union { uintptr_t x; const struct mspi_xip_cfg * val; } parm2 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_MSPI_XIP_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mspi_xip_config(controller, dev_id, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mspi_xip_config(controller, dev_id, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MSPI_XIP_CONFIG, mspi_xip_config, controller, dev_id, cfg); syscall__retval = mspi_xip_config(controller, dev_id, cfg); sys_port_trace_syscall_exit(K_SYSCALL_MSPI_XIP_CONFIG, mspi_xip_config, controller, dev_id, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mspi_scramble_config(const struct device * controller, const struct mspi_dev_id * dev_id, const struct mspi_scramble_cfg * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int mspi_scramble_config(const struct device * controller, const struct mspi_dev_id * dev_id, const struct mspi_scramble_cfg * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = controller };
|
||||
union { uintptr_t x; const struct mspi_dev_id * val; } parm1 = { .val = dev_id };
|
||||
union { uintptr_t x; const struct mspi_scramble_cfg * val; } parm2 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_MSPI_SCRAMBLE_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mspi_scramble_config(controller, dev_id, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mspi_scramble_config(controller, dev_id, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MSPI_SCRAMBLE_CONFIG, mspi_scramble_config, controller, dev_id, cfg); syscall__retval = mspi_scramble_config(controller, dev_id, cfg); sys_port_trace_syscall_exit(K_SYSCALL_MSPI_SCRAMBLE_CONFIG, mspi_scramble_config, controller, dev_id, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_mspi_timing_config(const struct device * controller, const struct mspi_dev_id * dev_id, const uint32_t param_mask, void * cfg);
|
||||
|
||||
__pinned_func
|
||||
static inline int mspi_timing_config(const struct device * controller, const struct mspi_dev_id * dev_id, const uint32_t param_mask, void * cfg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = controller };
|
||||
union { uintptr_t x; const struct mspi_dev_id * val; } parm1 = { .val = dev_id };
|
||||
union { uintptr_t x; const uint32_t val; } parm2 = { .val = param_mask };
|
||||
union { uintptr_t x; void * val; } parm3 = { .val = cfg };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_MSPI_TIMING_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_mspi_timing_config(controller, dev_id, param_mask, cfg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define mspi_timing_config(controller, dev_id, param_mask, cfg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_MSPI_TIMING_CONFIG, mspi_timing_config, controller, dev_id, param_mask, cfg); syscall__retval = mspi_timing_config(controller, dev_id, param_mask, cfg); sys_port_trace_syscall_exit(K_SYSCALL_MSPI_TIMING_CONFIG, mspi_timing_config, controller, dev_id, param_mask, cfg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,75 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_MUTEX_H
|
||||
#define Z_INCLUDE_SYSCALLS_MUTEX_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_z_sys_mutex_kernel_lock(struct sys_mutex * mutex, k_timeout_t timeout);
|
||||
|
||||
__pinned_func
|
||||
static inline int z_sys_mutex_kernel_lock(struct sys_mutex * mutex, k_timeout_t timeout)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct sys_mutex * val; } parm0 = { .val = mutex };
|
||||
union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm1 = { .val = timeout };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.split.lo, parm1.split.hi, K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_z_sys_mutex_kernel_lock(mutex, timeout);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define z_sys_mutex_kernel_lock(mutex, timeout) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK, z_sys_mutex_kernel_lock, mutex, timeout); syscall__retval = z_sys_mutex_kernel_lock(mutex, timeout); sys_port_trace_syscall_exit(K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK, z_sys_mutex_kernel_lock, mutex, timeout, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_z_sys_mutex_kernel_unlock(struct sys_mutex * mutex);
|
||||
|
||||
__pinned_func
|
||||
static inline int z_sys_mutex_kernel_unlock(struct sys_mutex * mutex)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct sys_mutex * val; } parm0 = { .val = mutex };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_z_sys_mutex_kernel_unlock(mutex);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define z_sys_mutex_kernel_unlock(mutex) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK, z_sys_mutex_kernel_unlock, mutex); syscall__retval = z_sys_mutex_kernel_unlock(mutex); sys_port_trace_syscall_exit(K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK, z_sys_mutex_kernel_unlock, mutex, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,270 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_NET_IF_H
|
||||
#define Z_INCLUDE_SYSCALLS_NET_IF_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_net_if_ipv6_addr_lookup_by_index(const struct in6_addr * addr);
|
||||
|
||||
__pinned_func
|
||||
static inline int net_if_ipv6_addr_lookup_by_index(const struct in6_addr * addr)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct 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 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 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 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 in6_addr * addr);
|
||||
|
||||
__pinned_func
|
||||
static inline bool net_if_ipv6_addr_rm_by_index(int index, const struct 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 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 in_addr * addr);
|
||||
|
||||
__pinned_func
|
||||
static inline int net_if_ipv4_addr_lookup_by_index(const struct in_addr * addr)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct 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 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 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 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 in_addr * addr);
|
||||
|
||||
__pinned_func
|
||||
static inline bool net_if_ipv4_addr_rm_by_index(int index, const struct 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 in_addr * val; } parm1 = { .val = addr };
|
||||
return (bool) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_if_ipv4_addr_rm_by_index(index, addr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_if_ipv4_addr_rm_by_index(index, addr) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX, net_if_ipv4_addr_rm_by_index, index, addr); syscall__retval = net_if_ipv4_addr_rm_by_index(index, addr); sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX, net_if_ipv4_addr_rm_by_index, index, addr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_net_if_ipv4_set_netmask_by_index(int index, const struct in_addr * netmask);
|
||||
|
||||
__pinned_func
|
||||
static inline bool net_if_ipv4_set_netmask_by_index(int index, const struct 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 in_addr * val; } parm1 = { .val = netmask };
|
||||
return (bool) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_INDEX);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_if_ipv4_set_netmask_by_index(index, netmask);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_if_ipv4_set_netmask_by_index(index, netmask) ({ bool syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_INDEX, net_if_ipv4_set_netmask_by_index, index, netmask); syscall__retval = net_if_ipv4_set_netmask_by_index(index, netmask); sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_INDEX, net_if_ipv4_set_netmask_by_index, index, netmask, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern bool z_impl_net_if_ipv4_set_netmask_by_addr_by_index(int index, const struct in_addr * addr, const struct in_addr * netmask);
|
||||
|
||||
__pinned_func
|
||||
static inline bool net_if_ipv4_set_netmask_by_addr_by_index(int index, const struct in_addr * addr, const struct 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 in_addr * val; } parm1 = { .val = addr };
|
||||
union { uintptr_t x; const struct 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 in_addr * gw);
|
||||
|
||||
__pinned_func
|
||||
static inline bool net_if_ipv4_set_gw_by_index(int index, const struct 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 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 */
|
||||
@@ -0,0 +1,79 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_NET_IP_H
|
||||
#define Z_INCLUDE_SYSCALLS_NET_IP_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_net_addr_pton(sa_family_t family, const char * src, void * dst);
|
||||
|
||||
__pinned_func
|
||||
static inline int net_addr_pton(sa_family_t family, const char * src, void * dst)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; 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(sa_family_t family, const void * src, char * dst, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline char * net_addr_ntop(sa_family_t family, const void * src, char * dst, size_t size)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; sa_family_t val; } parm0 = { .val = family };
|
||||
union { uintptr_t x; const void * val; } parm1 = { .val = src };
|
||||
union { uintptr_t x; char * val; } parm2 = { .val = dst };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = size };
|
||||
return (char *) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_NET_ADDR_NTOP);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_net_addr_ntop(family, src, dst, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define net_addr_ntop(family, src, dst, size) ({ char * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_NET_ADDR_NTOP, net_addr_ntop, family, src, dst, size); syscall__retval = net_addr_ntop(family, src, dst, size); sys_port_trace_syscall_exit(K_SYSCALL_NET_ADDR_NTOP, net_addr_ntop, family, src, dst, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,53 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_NRF_QSPI_NOR_H
|
||||
#define Z_INCLUDE_SYSCALLS_NRF_QSPI_NOR_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern void z_impl_nrf_qspi_nor_xip_enable(const struct device * dev, bool enable);
|
||||
|
||||
__pinned_func
|
||||
static inline void nrf_qspi_nor_xip_enable(const struct device * dev, bool enable)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; bool val; } parm1 = { .val = enable };
|
||||
(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_nrf_qspi_nor_xip_enable(dev, enable);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define nrf_qspi_nor_xip_enable(dev, enable) do { sys_port_trace_syscall_enter(K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE, nrf_qspi_nor_xip_enable, dev, enable); nrf_qspi_nor_xip_enable(dev, enable); sys_port_trace_syscall_exit(K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE, nrf_qspi_nor_xip_enable, dev, enable); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,52 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_OPAMP_H
|
||||
#define Z_INCLUDE_SYSCALLS_OPAMP_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_opamp_set_gain(const struct device * dev, enum opamp_gain gain);
|
||||
|
||||
__pinned_func
|
||||
static inline int opamp_set_gain(const struct device * dev, enum opamp_gain gain)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; enum opamp_gain val; } parm1 = { .val = gain };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_OPAMP_SET_GAIN);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_opamp_set_gain(dev, gain);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define opamp_set_gain(dev, gain) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_OPAMP_SET_GAIN, opamp_set_gain, dev, gain); syscall__retval = opamp_set_gain(dev, gain); sys_port_trace_syscall_exit(K_SYSCALL_OPAMP_SET_GAIN, opamp_set_gain, dev, gain, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,122 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_PECI_H
|
||||
#define Z_INCLUDE_SYSCALLS_PECI_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_peci_config(const struct device * dev, uint32_t bitrate);
|
||||
|
||||
__pinned_func
|
||||
static inline int peci_config(const struct device * dev, uint32_t bitrate)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = bitrate };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PECI_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_peci_config(dev, bitrate);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define peci_config(dev, bitrate) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PECI_CONFIG, peci_config, dev, bitrate); syscall__retval = peci_config(dev, bitrate); sys_port_trace_syscall_exit(K_SYSCALL_PECI_CONFIG, peci_config, dev, bitrate, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_peci_enable(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int peci_enable(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_PECI_ENABLE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_peci_enable(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define peci_enable(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PECI_ENABLE, peci_enable, dev); syscall__retval = peci_enable(dev); sys_port_trace_syscall_exit(K_SYSCALL_PECI_ENABLE, peci_enable, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_peci_disable(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int peci_disable(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_PECI_DISABLE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_peci_disable(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define peci_disable(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PECI_DISABLE, peci_disable, dev); syscall__retval = peci_disable(dev); sys_port_trace_syscall_exit(K_SYSCALL_PECI_DISABLE, peci_disable, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_peci_transfer(const struct device * dev, struct peci_msg * msg);
|
||||
|
||||
__pinned_func
|
||||
static inline int peci_transfer(const struct device * dev, struct peci_msg * msg)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct peci_msg * val; } parm1 = { .val = msg };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PECI_TRANSFER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_peci_transfer(dev, msg);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define peci_transfer(dev, msg) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PECI_TRANSFER, peci_transfer, dev, msg); syscall__retval = peci_transfer(dev, msg); sys_port_trace_syscall_exit(K_SYSCALL_PECI_TRANSFER, peci_transfer, dev, msg, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,146 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_PS2_H
|
||||
#define Z_INCLUDE_SYSCALLS_PS2_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_ps2_config(const struct device * dev, ps2_callback_t callback_isr);
|
||||
|
||||
__pinned_func
|
||||
static inline int ps2_config(const struct device * dev, ps2_callback_t callback_isr)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; ps2_callback_t val; } parm1 = { .val = callback_isr };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PS2_CONFIG);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ps2_config(dev, callback_isr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ps2_config(dev, callback_isr) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PS2_CONFIG, ps2_config, dev, callback_isr); syscall__retval = ps2_config(dev, callback_isr); sys_port_trace_syscall_exit(K_SYSCALL_PS2_CONFIG, ps2_config, dev, callback_isr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ps2_write(const struct device * dev, uint8_t value);
|
||||
|
||||
__pinned_func
|
||||
static inline int ps2_write(const struct device * dev, uint8_t value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = value };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PS2_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ps2_write(dev, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ps2_write(dev, value) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PS2_WRITE, ps2_write, dev, value); syscall__retval = ps2_write(dev, value); sys_port_trace_syscall_exit(K_SYSCALL_PS2_WRITE, ps2_write, dev, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ps2_read(const struct device * dev, uint8_t * value);
|
||||
|
||||
__pinned_func
|
||||
static inline int ps2_read(const struct device * dev, uint8_t * value)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t * val; } parm1 = { .val = value };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PS2_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ps2_read(dev, value);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ps2_read(dev, value) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PS2_READ, ps2_read, dev, value); syscall__retval = ps2_read(dev, value); sys_port_trace_syscall_exit(K_SYSCALL_PS2_READ, ps2_read, dev, value, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ps2_enable_callback(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int ps2_enable_callback(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_PS2_ENABLE_CALLBACK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ps2_enable_callback(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ps2_enable_callback(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PS2_ENABLE_CALLBACK, ps2_enable_callback, dev); syscall__retval = ps2_enable_callback(dev); sys_port_trace_syscall_exit(K_SYSCALL_PS2_ENABLE_CALLBACK, ps2_enable_callback, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_ps2_disable_callback(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int ps2_disable_callback(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_PS2_DISABLE_CALLBACK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ps2_disable_callback(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ps2_disable_callback(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PS2_DISABLE_CALLBACK, ps2_disable_callback, dev); syscall__retval = ps2_disable_callback(dev); sys_port_trace_syscall_exit(K_SYSCALL_PS2_DISABLE_CALLBACK, ps2_disable_callback, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,133 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_PSI5_H
|
||||
#define Z_INCLUDE_SYSCALLS_PSI5_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_psi5_start_sync(const struct device * dev, uint8_t channel);
|
||||
|
||||
__pinned_func
|
||||
static inline int psi5_start_sync(const struct device * dev, uint8_t channel)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = channel };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PSI5_START_SYNC);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_psi5_start_sync(dev, channel);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define psi5_start_sync(dev, channel) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PSI5_START_SYNC, psi5_start_sync, dev, channel); syscall__retval = psi5_start_sync(dev, channel); sys_port_trace_syscall_exit(K_SYSCALL_PSI5_START_SYNC, psi5_start_sync, dev, channel, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_psi5_stop_sync(const struct device * dev, uint8_t channel);
|
||||
|
||||
__pinned_func
|
||||
static inline int psi5_stop_sync(const struct device * dev, uint8_t channel)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = channel };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PSI5_STOP_SYNC);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_psi5_stop_sync(dev, channel);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define psi5_stop_sync(dev, channel) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PSI5_STOP_SYNC, psi5_stop_sync, dev, channel); syscall__retval = psi5_stop_sync(dev, channel); sys_port_trace_syscall_exit(K_SYSCALL_PSI5_STOP_SYNC, psi5_stop_sync, dev, channel, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_psi5_send(const struct device * dev, uint8_t channel, const uint64_t data, k_timeout_t timeout, psi5_tx_callback_t callback, void * user_data);
|
||||
|
||||
__pinned_func
|
||||
static inline int psi5_send(const struct device * dev, uint8_t channel, const uint64_t data, k_timeout_t timeout, psi5_tx_callback_t callback, void * user_data)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = channel };
|
||||
union { uintptr_t x; const uint64_t val; } parm2 = { .val = data };
|
||||
union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm3 = { .val = timeout };
|
||||
union { uintptr_t x; psi5_tx_callback_t val; } parm4 = { .val = callback };
|
||||
union { uintptr_t x; void * val; } parm5 = { .val = user_data };
|
||||
uintptr_t more[] = {
|
||||
parm4.x,
|
||||
parm5.x
|
||||
};
|
||||
return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.split.lo, parm3.split.hi, (uintptr_t) &more, K_SYSCALL_PSI5_SEND);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_psi5_send(dev, channel, data, timeout, callback, user_data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define psi5_send(dev, channel, data, timeout, callback, user_data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PSI5_SEND, psi5_send, dev, channel, data, timeout, callback, user_data); syscall__retval = psi5_send(dev, channel, data, timeout, callback, user_data); sys_port_trace_syscall_exit(K_SYSCALL_PSI5_SEND, psi5_send, dev, channel, data, timeout, callback, user_data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_psi5_register_callback(const struct device * dev, uint8_t channel, struct psi5_rx_callback_configs callback_configs);
|
||||
|
||||
__pinned_func
|
||||
static inline int psi5_register_callback(const struct device * dev, uint8_t channel, struct psi5_rx_callback_configs callback_configs)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; uint8_t val; } parm1 = { .val = channel };
|
||||
union { uintptr_t x; struct psi5_rx_callback_configs val; } parm2 = { .val = callback_configs };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_PSI5_REGISTER_CALLBACK);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_psi5_register_callback(dev, channel, callback_configs);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define psi5_register_callback(dev, channel, callback_configs) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PSI5_REGISTER_CALLBACK, psi5_register_callback, dev, channel, callback_configs); syscall__retval = psi5_register_callback(dev, channel, callback_configs); sys_port_trace_syscall_exit(K_SYSCALL_PSI5_REGISTER_CALLBACK, psi5_register_callback, dev, channel, callback_configs, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,52 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_PTP_CLOCK_H
|
||||
#define Z_INCLUDE_SYSCALLS_PTP_CLOCK_H
|
||||
|
||||
|
||||
#include <zephyr/tracing/tracing_syscall.h>
|
||||
|
||||
#ifndef _ASMLANGUAGE
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <zephyr/syscall_list.h>
|
||||
#include <zephyr/syscall.h>
|
||||
|
||||
#include <zephyr/linker/sections.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int z_impl_ptp_clock_get(const struct device * dev, struct net_ptp_time * tm);
|
||||
|
||||
__pinned_func
|
||||
static inline int ptp_clock_get(const struct device * dev, struct net_ptp_time * tm)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct net_ptp_time * val; } parm1 = { .val = tm };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PTP_CLOCK_GET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_ptp_clock_get(dev, tm);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define ptp_clock_get(dev, tm) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_PTP_CLOCK_GET, ptp_clock_get, dev, tm); syscall__retval = ptp_clock_get(dev, tm); sys_port_trace_syscall_exit(K_SYSCALL_PTP_CLOCK_GET, ptp_clock_get, dev, tm, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,160 @@
|
||||
/* 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 */
|
||||
@@ -0,0 +1,77 @@
|
||||
/* 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 */
|
||||
@@ -0,0 +1,147 @@
|
||||
/* 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 */
|
||||
@@ -0,0 +1,125 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_RESET_H
|
||||
#define Z_INCLUDE_SYSCALLS_RESET_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_reset_status(const struct device * dev, uint32_t id, uint8_t * status);
|
||||
|
||||
__pinned_func
|
||||
static inline int reset_status(const struct device * dev, uint32_t id, uint8_t * status)
|
||||
{
|
||||
#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 = id };
|
||||
union { uintptr_t x; uint8_t * val; } parm2 = { .val = status };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_RESET_STATUS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_reset_status(dev, id, status);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define reset_status(dev, id, status) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RESET_STATUS, reset_status, dev, id, status); syscall__retval = reset_status(dev, id, status); sys_port_trace_syscall_exit(K_SYSCALL_RESET_STATUS, reset_status, dev, id, status, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_reset_line_assert(const struct device * dev, uint32_t id);
|
||||
|
||||
__pinned_func
|
||||
static inline int reset_line_assert(const struct device * dev, uint32_t 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 = id };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RESET_LINE_ASSERT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_reset_line_assert(dev, id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define reset_line_assert(dev, id) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RESET_LINE_ASSERT, reset_line_assert, dev, id); syscall__retval = reset_line_assert(dev, id); sys_port_trace_syscall_exit(K_SYSCALL_RESET_LINE_ASSERT, reset_line_assert, dev, id, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_reset_line_deassert(const struct device * dev, uint32_t id);
|
||||
|
||||
__pinned_func
|
||||
static inline int reset_line_deassert(const struct device * dev, uint32_t 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 = id };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RESET_LINE_DEASSERT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_reset_line_deassert(dev, id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define reset_line_deassert(dev, id) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RESET_LINE_DEASSERT, reset_line_deassert, dev, id); syscall__retval = reset_line_deassert(dev, id); sys_port_trace_syscall_exit(K_SYSCALL_RESET_LINE_DEASSERT, reset_line_deassert, dev, id, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_reset_line_toggle(const struct device * dev, uint32_t id);
|
||||
|
||||
__pinned_func
|
||||
static inline int reset_line_toggle(const struct device * dev, uint32_t 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 = id };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RESET_LINE_TOGGLE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_reset_line_toggle(dev, id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define reset_line_toggle(dev, id) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RESET_LINE_TOGGLE, reset_line_toggle, dev, id); syscall__retval = reset_line_toggle(dev, id); sys_port_trace_syscall_exit(K_SYSCALL_RESET_LINE_TOGGLE, reset_line_toggle, dev, id, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,126 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_RETAINED_MEM_H
|
||||
#define Z_INCLUDE_SYSCALLS_RETAINED_MEM_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_retained_mem_size(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline ssize_t retained_mem_size(const struct device * dev)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
return (ssize_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_RETAINED_MEM_SIZE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_retained_mem_size(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define retained_mem_size(dev) ({ ssize_t syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RETAINED_MEM_SIZE, retained_mem_size, dev); syscall__retval = retained_mem_size(dev); sys_port_trace_syscall_exit(K_SYSCALL_RETAINED_MEM_SIZE, retained_mem_size, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_retained_mem_read(const struct device * dev, off_t offset, uint8_t * buffer, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int retained_mem_read(const struct device * dev, off_t offset, uint8_t * buffer, 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; uint8_t * val; } parm2 = { .val = buffer };
|
||||
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_RETAINED_MEM_READ);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_retained_mem_read(dev, offset, buffer, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define retained_mem_read(dev, offset, buffer, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RETAINED_MEM_READ, retained_mem_read, dev, offset, buffer, size); syscall__retval = retained_mem_read(dev, offset, buffer, size); sys_port_trace_syscall_exit(K_SYSCALL_RETAINED_MEM_READ, retained_mem_read, dev, offset, buffer, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_retained_mem_write(const struct device * dev, off_t offset, const uint8_t * buffer, size_t size);
|
||||
|
||||
__pinned_func
|
||||
static inline int retained_mem_write(const struct device * dev, off_t offset, const uint8_t * buffer, 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; const uint8_t * val; } parm2 = { .val = buffer };
|
||||
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_RETAINED_MEM_WRITE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_retained_mem_write(dev, offset, buffer, size);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define retained_mem_write(dev, offset, buffer, size) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RETAINED_MEM_WRITE, retained_mem_write, dev, offset, buffer, size); syscall__retval = retained_mem_write(dev, offset, buffer, size); sys_port_trace_syscall_exit(K_SYSCALL_RETAINED_MEM_WRITE, retained_mem_write, dev, offset, buffer, size, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_retained_mem_clear(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int retained_mem_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_RETAINED_MEM_CLEAR);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_retained_mem_clear(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define retained_mem_clear(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RETAINED_MEM_CLEAR, retained_mem_clear, dev); syscall__retval = retained_mem_clear(dev); sys_port_trace_syscall_exit(K_SYSCALL_RETAINED_MEM_CLEAR, retained_mem_clear, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,225 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_RTC_H
|
||||
#define Z_INCLUDE_SYSCALLS_RTC_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_rtc_set_time(const struct device * dev, const struct rtc_time * timeptr);
|
||||
|
||||
__pinned_func
|
||||
static inline int rtc_set_time(const struct device * dev, const struct rtc_time * timeptr)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; const struct rtc_time * val; } parm1 = { .val = timeptr };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RTC_SET_TIME);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_rtc_set_time(dev, timeptr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtc_set_time(dev, timeptr) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RTC_SET_TIME, rtc_set_time, dev, timeptr); syscall__retval = rtc_set_time(dev, timeptr); sys_port_trace_syscall_exit(K_SYSCALL_RTC_SET_TIME, rtc_set_time, dev, timeptr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_rtc_get_time(const struct device * dev, struct rtc_time * timeptr);
|
||||
|
||||
__pinned_func
|
||||
static inline int rtc_get_time(const struct device * dev, struct rtc_time * timeptr)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct rtc_time * val; } parm1 = { .val = timeptr };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RTC_GET_TIME);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_rtc_get_time(dev, timeptr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtc_get_time(dev, timeptr) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RTC_GET_TIME, rtc_get_time, dev, timeptr); syscall__retval = rtc_get_time(dev, timeptr); sys_port_trace_syscall_exit(K_SYSCALL_RTC_GET_TIME, rtc_get_time, dev, timeptr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_rtc_alarm_get_supported_fields(const struct device * dev, uint16_t id, uint16_t * mask);
|
||||
|
||||
__pinned_func
|
||||
static inline int rtc_alarm_get_supported_fields(const struct device * dev, uint16_t id, uint16_t * mask)
|
||||
{
|
||||
#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; uint16_t * val; } parm2 = { .val = mask };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_RTC_ALARM_GET_SUPPORTED_FIELDS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_rtc_alarm_get_supported_fields(dev, id, mask);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtc_alarm_get_supported_fields(dev, id, mask) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RTC_ALARM_GET_SUPPORTED_FIELDS, rtc_alarm_get_supported_fields, dev, id, mask); syscall__retval = rtc_alarm_get_supported_fields(dev, id, mask); sys_port_trace_syscall_exit(K_SYSCALL_RTC_ALARM_GET_SUPPORTED_FIELDS, rtc_alarm_get_supported_fields, dev, id, mask, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_rtc_alarm_set_time(const struct device * dev, uint16_t id, uint16_t mask, const struct rtc_time * timeptr);
|
||||
|
||||
__pinned_func
|
||||
static inline int rtc_alarm_set_time(const struct device * dev, uint16_t id, uint16_t mask, const struct rtc_time * timeptr)
|
||||
{
|
||||
#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; uint16_t val; } parm2 = { .val = mask };
|
||||
union { uintptr_t x; const struct rtc_time * val; } parm3 = { .val = timeptr };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_RTC_ALARM_SET_TIME);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_rtc_alarm_set_time(dev, id, mask, timeptr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtc_alarm_set_time(dev, id, mask, timeptr) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RTC_ALARM_SET_TIME, rtc_alarm_set_time, dev, id, mask, timeptr); syscall__retval = rtc_alarm_set_time(dev, id, mask, timeptr); sys_port_trace_syscall_exit(K_SYSCALL_RTC_ALARM_SET_TIME, rtc_alarm_set_time, dev, id, mask, timeptr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_rtc_alarm_get_time(const struct device * dev, uint16_t id, uint16_t * mask, struct rtc_time * timeptr);
|
||||
|
||||
__pinned_func
|
||||
static inline int rtc_alarm_get_time(const struct device * dev, uint16_t id, uint16_t * mask, struct rtc_time * timeptr)
|
||||
{
|
||||
#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; uint16_t * val; } parm2 = { .val = mask };
|
||||
union { uintptr_t x; struct rtc_time * val; } parm3 = { .val = timeptr };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_RTC_ALARM_GET_TIME);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_rtc_alarm_get_time(dev, id, mask, timeptr);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtc_alarm_get_time(dev, id, mask, timeptr) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RTC_ALARM_GET_TIME, rtc_alarm_get_time, dev, id, mask, timeptr); syscall__retval = rtc_alarm_get_time(dev, id, mask, timeptr); sys_port_trace_syscall_exit(K_SYSCALL_RTC_ALARM_GET_TIME, rtc_alarm_get_time, dev, id, mask, timeptr, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_rtc_alarm_is_pending(const struct device * dev, uint16_t id);
|
||||
|
||||
__pinned_func
|
||||
static inline int rtc_alarm_is_pending(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_RTC_ALARM_IS_PENDING);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_rtc_alarm_is_pending(dev, id);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtc_alarm_is_pending(dev, id) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RTC_ALARM_IS_PENDING, rtc_alarm_is_pending, dev, id); syscall__retval = rtc_alarm_is_pending(dev, id); sys_port_trace_syscall_exit(K_SYSCALL_RTC_ALARM_IS_PENDING, rtc_alarm_is_pending, dev, id, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_rtc_set_calibration(const struct device * dev, int32_t calibration);
|
||||
|
||||
__pinned_func
|
||||
static inline int rtc_set_calibration(const struct device * dev, int32_t calibration)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; int32_t val; } parm1 = { .val = calibration };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RTC_SET_CALIBRATION);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_rtc_set_calibration(dev, calibration);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtc_set_calibration(dev, calibration) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RTC_SET_CALIBRATION, rtc_set_calibration, dev, calibration); syscall__retval = rtc_set_calibration(dev, calibration); sys_port_trace_syscall_exit(K_SYSCALL_RTC_SET_CALIBRATION, rtc_set_calibration, dev, calibration, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_rtc_get_calibration(const struct device * dev, int32_t * calibration);
|
||||
|
||||
__pinned_func
|
||||
static inline int rtc_get_calibration(const struct device * dev, int32_t * calibration)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; int32_t * val; } parm1 = { .val = calibration };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RTC_GET_CALIBRATION);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_rtc_get_calibration(dev, calibration);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtc_get_calibration(dev, calibration) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RTC_GET_CALIBRATION, rtc_get_calibration, dev, calibration); syscall__retval = rtc_get_calibration(dev, calibration); sys_port_trace_syscall_exit(K_SYSCALL_RTC_GET_CALIBRATION, rtc_get_calibration, dev, calibration, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,251 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_RTIO_H
|
||||
#define Z_INCLUDE_SYSCALLS_RTIO_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_rtio_cqe_get_mempool_buffer(const struct rtio * r, struct rtio_cqe * cqe, uint8_t ** buff, uint32_t * buff_len);
|
||||
|
||||
__pinned_func
|
||||
static inline int rtio_cqe_get_mempool_buffer(const struct rtio * r, struct rtio_cqe * cqe, uint8_t ** buff, uint32_t * buff_len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct rtio * val; } parm0 = { .val = r };
|
||||
union { uintptr_t x; struct rtio_cqe * val; } parm1 = { .val = cqe };
|
||||
union { uintptr_t x; uint8_t ** val; } parm2 = { .val = buff };
|
||||
union { uintptr_t x; uint32_t * val; } parm3 = { .val = buff_len };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_RTIO_CQE_GET_MEMPOOL_BUFFER);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_rtio_cqe_get_mempool_buffer(r, cqe, buff, buff_len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtio_cqe_get_mempool_buffer(r, cqe, buff, buff_len) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RTIO_CQE_GET_MEMPOOL_BUFFER, rtio_cqe_get_mempool_buffer, r, cqe, buff, buff_len); syscall__retval = rtio_cqe_get_mempool_buffer(r, cqe, buff, buff_len); sys_port_trace_syscall_exit(K_SYSCALL_RTIO_CQE_GET_MEMPOOL_BUFFER, rtio_cqe_get_mempool_buffer, r, cqe, buff, buff_len, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_rtio_release_buffer(struct rtio * r, void * buff, uint32_t buff_len);
|
||||
|
||||
__pinned_func
|
||||
static inline void rtio_release_buffer(struct rtio * r, void * buff, uint32_t buff_len)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct rtio * val; } parm0 = { .val = r };
|
||||
union { uintptr_t x; void * val; } parm1 = { .val = buff };
|
||||
union { uintptr_t x; uint32_t val; } parm2 = { .val = buff_len };
|
||||
(void) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_RTIO_RELEASE_BUFFER);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_rtio_release_buffer(r, buff, buff_len);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtio_release_buffer(r, buff, buff_len) do { sys_port_trace_syscall_enter(K_SYSCALL_RTIO_RELEASE_BUFFER, rtio_release_buffer, r, buff, buff_len); rtio_release_buffer(r, buff, buff_len); sys_port_trace_syscall_exit(K_SYSCALL_RTIO_RELEASE_BUFFER, rtio_release_buffer, r, buff, buff_len); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_rtio_sqe_cancel(struct rtio_sqe * sqe);
|
||||
|
||||
__pinned_func
|
||||
static inline int rtio_sqe_cancel(struct rtio_sqe * sqe)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct rtio_sqe * val; } parm0 = { .val = sqe };
|
||||
return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_RTIO_SQE_CANCEL);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_rtio_sqe_cancel(sqe);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtio_sqe_cancel(sqe) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RTIO_SQE_CANCEL, rtio_sqe_cancel, sqe); syscall__retval = rtio_sqe_cancel(sqe); sys_port_trace_syscall_exit(K_SYSCALL_RTIO_SQE_CANCEL, rtio_sqe_cancel, sqe, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_rtio_sqe_signal(struct rtio_sqe * sqe);
|
||||
|
||||
__pinned_func
|
||||
static inline void rtio_sqe_signal(struct rtio_sqe * sqe)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct rtio_sqe * val; } parm0 = { .val = sqe };
|
||||
(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_RTIO_SQE_SIGNAL);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_rtio_sqe_signal(sqe);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtio_sqe_signal(sqe) do { sys_port_trace_syscall_enter(K_SYSCALL_RTIO_SQE_SIGNAL, rtio_sqe_signal, sqe); rtio_sqe_signal(sqe); sys_port_trace_syscall_exit(K_SYSCALL_RTIO_SQE_SIGNAL, rtio_sqe_signal, sqe); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_rtio_sqe_copy_in_get_handles(struct rtio * r, const struct rtio_sqe * sqes, struct rtio_sqe ** handle, size_t sqe_count);
|
||||
|
||||
__pinned_func
|
||||
static inline int rtio_sqe_copy_in_get_handles(struct rtio * r, const struct rtio_sqe * sqes, struct rtio_sqe ** handle, size_t sqe_count)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct rtio * val; } parm0 = { .val = r };
|
||||
union { uintptr_t x; const struct rtio_sqe * val; } parm1 = { .val = sqes };
|
||||
union { uintptr_t x; struct rtio_sqe ** val; } parm2 = { .val = handle };
|
||||
union { uintptr_t x; size_t val; } parm3 = { .val = sqe_count };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_RTIO_SQE_COPY_IN_GET_HANDLES);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_rtio_sqe_copy_in_get_handles(r, sqes, handle, sqe_count);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtio_sqe_copy_in_get_handles(r, sqes, handle, sqe_count) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RTIO_SQE_COPY_IN_GET_HANDLES, rtio_sqe_copy_in_get_handles, r, sqes, handle, sqe_count); syscall__retval = rtio_sqe_copy_in_get_handles(r, sqes, handle, sqe_count); sys_port_trace_syscall_exit(K_SYSCALL_RTIO_SQE_COPY_IN_GET_HANDLES, rtio_sqe_copy_in_get_handles, r, sqes, handle, sqe_count, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_rtio_cqe_copy_out(struct rtio * r, struct rtio_cqe * cqes, size_t cqe_count, k_timeout_t timeout);
|
||||
|
||||
__pinned_func
|
||||
static inline int rtio_cqe_copy_out(struct rtio * r, struct rtio_cqe * cqes, size_t cqe_count, k_timeout_t timeout)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct rtio * val; } parm0 = { .val = r };
|
||||
union { uintptr_t x; struct rtio_cqe * val; } parm1 = { .val = cqes };
|
||||
union { uintptr_t x; size_t val; } parm2 = { .val = cqe_count };
|
||||
union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm3 = { .val = timeout };
|
||||
return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.split.lo, parm3.split.hi, K_SYSCALL_RTIO_CQE_COPY_OUT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_rtio_cqe_copy_out(r, cqes, cqe_count, timeout);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtio_cqe_copy_out(r, cqes, cqe_count, timeout) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RTIO_CQE_COPY_OUT, rtio_cqe_copy_out, r, cqes, cqe_count, timeout); syscall__retval = rtio_cqe_copy_out(r, cqes, cqe_count, timeout); sys_port_trace_syscall_exit(K_SYSCALL_RTIO_CQE_COPY_OUT, rtio_cqe_copy_out, r, cqes, cqe_count, timeout, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_rtio_submit(struct rtio * r, uint32_t wait_count);
|
||||
|
||||
__pinned_func
|
||||
static inline int rtio_submit(struct rtio * r, uint32_t wait_count)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct rtio * val; } parm0 = { .val = r };
|
||||
union { uintptr_t x; uint32_t val; } parm1 = { .val = wait_count };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RTIO_SUBMIT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_rtio_submit(r, wait_count);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtio_submit(r, wait_count) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RTIO_SUBMIT, rtio_submit, r, wait_count); syscall__retval = rtio_submit(r, wait_count); sys_port_trace_syscall_exit(K_SYSCALL_RTIO_SUBMIT, rtio_submit, r, wait_count, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern struct rtio * z_impl_rtio_pool_acquire(struct rtio_pool * pool);
|
||||
|
||||
__pinned_func
|
||||
static inline struct rtio * rtio_pool_acquire(struct rtio_pool * pool)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct rtio_pool * val; } parm0 = { .val = pool };
|
||||
return (struct rtio *) arch_syscall_invoke1(parm0.x, K_SYSCALL_RTIO_POOL_ACQUIRE);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_rtio_pool_acquire(pool);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtio_pool_acquire(pool) ({ struct rtio * syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_RTIO_POOL_ACQUIRE, rtio_pool_acquire, pool); syscall__retval = rtio_pool_acquire(pool); sys_port_trace_syscall_exit(K_SYSCALL_RTIO_POOL_ACQUIRE, rtio_pool_acquire, pool, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern void z_impl_rtio_pool_release(struct rtio_pool * pool, struct rtio * r);
|
||||
|
||||
__pinned_func
|
||||
static inline void rtio_pool_release(struct rtio_pool * pool, struct rtio * r)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; struct rtio_pool * val; } parm0 = { .val = pool };
|
||||
union { uintptr_t x; struct rtio * val; } parm1 = { .val = r };
|
||||
(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RTIO_POOL_RELEASE);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
z_impl_rtio_pool_release(pool, r);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define rtio_pool_release(pool, r) do { sys_port_trace_syscall_enter(K_SYSCALL_RTIO_POOL_RELEASE, rtio_pool_release, pool, r); rtio_pool_release(pool, r); sys_port_trace_syscall_exit(K_SYSCALL_RTIO_POOL_RELEASE, rtio_pool_release, pool, r); } while(false)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* include guard */
|
||||
@@ -0,0 +1,243 @@
|
||||
/* auto-generated by gen_syscalls.py, don't edit */
|
||||
|
||||
#ifndef Z_INCLUDE_SYSCALLS_SDHC_H
|
||||
#define Z_INCLUDE_SYSCALLS_SDHC_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_sdhc_hw_reset(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int sdhc_hw_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_SDHC_HW_RESET);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sdhc_hw_reset(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sdhc_hw_reset(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SDHC_HW_RESET, sdhc_hw_reset, dev); syscall__retval = sdhc_hw_reset(dev); sys_port_trace_syscall_exit(K_SYSCALL_SDHC_HW_RESET, sdhc_hw_reset, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sdhc_request(const struct device * dev, struct sdhc_command * cmd, struct sdhc_data * data);
|
||||
|
||||
__pinned_func
|
||||
static inline int sdhc_request(const struct device * dev, struct sdhc_command * cmd, struct sdhc_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 sdhc_command * val; } parm1 = { .val = cmd };
|
||||
union { uintptr_t x; struct sdhc_data * val; } parm2 = { .val = data };
|
||||
return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_SDHC_REQUEST);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sdhc_request(dev, cmd, data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sdhc_request(dev, cmd, data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SDHC_REQUEST, sdhc_request, dev, cmd, data); syscall__retval = sdhc_request(dev, cmd, data); sys_port_trace_syscall_exit(K_SYSCALL_SDHC_REQUEST, sdhc_request, dev, cmd, data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sdhc_set_io(const struct device * dev, struct sdhc_io * io);
|
||||
|
||||
__pinned_func
|
||||
static inline int sdhc_set_io(const struct device * dev, struct sdhc_io * io)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct sdhc_io * val; } parm1 = { .val = io };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SDHC_SET_IO);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sdhc_set_io(dev, io);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sdhc_set_io(dev, io) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SDHC_SET_IO, sdhc_set_io, dev, io); syscall__retval = sdhc_set_io(dev, io); sys_port_trace_syscall_exit(K_SYSCALL_SDHC_SET_IO, sdhc_set_io, dev, io, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sdhc_card_present(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int sdhc_card_present(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_SDHC_CARD_PRESENT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sdhc_card_present(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sdhc_card_present(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SDHC_CARD_PRESENT, sdhc_card_present, dev); syscall__retval = sdhc_card_present(dev); sys_port_trace_syscall_exit(K_SYSCALL_SDHC_CARD_PRESENT, sdhc_card_present, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sdhc_execute_tuning(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int sdhc_execute_tuning(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_SDHC_EXECUTE_TUNING);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sdhc_execute_tuning(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sdhc_execute_tuning(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SDHC_EXECUTE_TUNING, sdhc_execute_tuning, dev); syscall__retval = sdhc_execute_tuning(dev); sys_port_trace_syscall_exit(K_SYSCALL_SDHC_EXECUTE_TUNING, sdhc_execute_tuning, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sdhc_card_busy(const struct device * dev);
|
||||
|
||||
__pinned_func
|
||||
static inline int sdhc_card_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_SDHC_CARD_BUSY);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sdhc_card_busy(dev);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sdhc_card_busy(dev) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SDHC_CARD_BUSY, sdhc_card_busy, dev); syscall__retval = sdhc_card_busy(dev); sys_port_trace_syscall_exit(K_SYSCALL_SDHC_CARD_BUSY, sdhc_card_busy, dev, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sdhc_get_host_props(const struct device * dev, struct sdhc_host_props * props);
|
||||
|
||||
__pinned_func
|
||||
static inline int sdhc_get_host_props(const struct device * dev, struct sdhc_host_props * props)
|
||||
{
|
||||
#ifdef CONFIG_USERSPACE
|
||||
if (z_syscall_trap()) {
|
||||
union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
|
||||
union { uintptr_t x; struct sdhc_host_props * val; } parm1 = { .val = props };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SDHC_GET_HOST_PROPS);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sdhc_get_host_props(dev, props);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sdhc_get_host_props(dev, props) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SDHC_GET_HOST_PROPS, sdhc_get_host_props, dev, props); syscall__retval = sdhc_get_host_props(dev, props); sys_port_trace_syscall_exit(K_SYSCALL_SDHC_GET_HOST_PROPS, sdhc_get_host_props, dev, props, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sdhc_enable_interrupt(const struct device * dev, sdhc_interrupt_cb_t callback, int sources, void * user_data);
|
||||
|
||||
__pinned_func
|
||||
static inline int sdhc_enable_interrupt(const struct device * dev, sdhc_interrupt_cb_t callback, int sources, 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; sdhc_interrupt_cb_t val; } parm1 = { .val = callback };
|
||||
union { uintptr_t x; int val; } parm2 = { .val = sources };
|
||||
union { uintptr_t x; void * val; } parm3 = { .val = user_data };
|
||||
return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_SDHC_ENABLE_INTERRUPT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sdhc_enable_interrupt(dev, callback, sources, user_data);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sdhc_enable_interrupt(dev, callback, sources, user_data) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SDHC_ENABLE_INTERRUPT, sdhc_enable_interrupt, dev, callback, sources, user_data); syscall__retval = sdhc_enable_interrupt(dev, callback, sources, user_data); sys_port_trace_syscall_exit(K_SYSCALL_SDHC_ENABLE_INTERRUPT, sdhc_enable_interrupt, dev, callback, sources, user_data, syscall__retval); syscall__retval; })
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
extern int z_impl_sdhc_disable_interrupt(const struct device * dev, int sources);
|
||||
|
||||
__pinned_func
|
||||
static inline int sdhc_disable_interrupt(const struct device * dev, int sources)
|
||||
{
|
||||
#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 = sources };
|
||||
return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SDHC_DISABLE_INTERRUPT);
|
||||
}
|
||||
#endif
|
||||
compiler_barrier();
|
||||
return z_impl_sdhc_disable_interrupt(dev, sources);
|
||||
}
|
||||
|
||||
#if defined(CONFIG_TRACING_SYSCALL)
|
||||
#ifndef DISABLE_SYSCALL_TRACING
|
||||
|
||||
#define sdhc_disable_interrupt(dev, sources) ({ int syscall__retval; sys_port_trace_syscall_enter(K_SYSCALL_SDHC_DISABLE_INTERRUPT, sdhc_disable_interrupt, dev, sources); syscall__retval = sdhc_disable_interrupt(dev, sources); sys_port_trace_syscall_exit(K_SYSCALL_SDHC_DISABLE_INTERRUPT, sdhc_disable_interrupt, dev, sources, 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