Copy disabled (too large)
Download .txt
Showing preview only (13,550K chars total). Download the full file to get everything.
Repository: embassy-rs/embassy
Branch: main
Commit: 165870484d2c
Files: 2345
Total size: 12.5 MB
Directory structure:
gitextract_vlawd1i1/
├── .gitattributes
├── .github/
│ ├── ci/
│ │ ├── book.sh
│ │ ├── build-nightly.sh
│ │ ├── build-xtensa.sh
│ │ ├── build.sh
│ │ ├── doc.sh
│ │ ├── janitor.sh
│ │ ├── rustfmt.sh
│ │ ├── test-nightly.sh
│ │ └── test.sh
│ └── workflows/
│ ├── matrix-bot-issues.yml
│ └── matrix-bot.yml
├── .gitignore
├── .helix/
│ └── languages.toml
├── .vscode/
│ ├── .gitignore
│ ├── extensions.json
│ └── settings.json
├── LICENSE-APACHE
├── LICENSE-CC-BY-SA
├── LICENSE-MIT
├── NOTICE.md
├── README.md
├── RELEASE.md
├── ci-nightly.sh
├── ci-xtensa.sh
├── ci.sh
├── cyw43/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── bluetooth.rs
│ ├── consts.rs
│ ├── control.rs
│ ├── countries.rs
│ ├── events.rs
│ ├── fmt.rs
│ ├── ioctl.rs
│ ├── lib.rs
│ ├── runner.rs
│ ├── sdio.rs
│ ├── spi.rs
│ ├── structs.rs
│ └── util.rs
├── cyw43-firmware/
│ ├── .gitignore
│ ├── LICENSE-permissive-binary-license-1.0.txt
│ ├── README.md
│ └── write_nvrams.rs
├── cyw43-pio/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── docs/
│ ├── Makefile
│ ├── README.md
│ ├── examples/
│ │ ├── basic/
│ │ │ ├── .cargo/
│ │ │ │ └── config.toml
│ │ │ ├── Cargo.toml
│ │ │ ├── build.rs
│ │ │ ├── memory.x
│ │ │ └── src/
│ │ │ └── main.rs
│ │ └── layer-by-layer/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── blinky-async/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── blinky-hal/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── blinky-irq/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── blinky-pac/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ └── memory.x
│ ├── images/
│ │ ├── embassy_executor.drawio
│ │ └── embassy_irq.drawio
│ ├── index.adoc
│ └── pages/
│ ├── basic_application.adoc
│ ├── beginners.adoc
│ ├── best_practices.adoc
│ ├── bootloader.adoc
│ ├── developer.adoc
│ ├── developer_stm32.adoc
│ ├── embassy_in_the_wild.adoc
│ ├── examples.adoc
│ ├── faq.adoc
│ ├── getting_started.adoc
│ ├── hal.adoc
│ ├── imxrt.adoc
│ ├── layer_by_layer.adoc
│ ├── mcxa.adoc
│ ├── microchip.adoc
│ ├── new_project.adoc
│ ├── nrf.adoc
│ ├── overview.adoc
│ ├── project_structure.adoc
│ ├── runtime.adoc
│ ├── sharing_peripherals.adoc
│ ├── stm32.adoc
│ ├── system.adoc
│ └── time_keeping.adoc
├── embassy-boot/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── boot_loader.rs
│ ├── digest_adapters/
│ │ ├── ed25519_dalek.rs
│ │ ├── mod.rs
│ │ └── salty.rs
│ ├── firmware_updater/
│ │ ├── asynch.rs
│ │ ├── blocking.rs
│ │ └── mod.rs
│ ├── fmt.rs
│ ├── lib.rs
│ ├── mem_flash.rs
│ └── test_flash/
│ ├── asynch.rs
│ ├── blocking.rs
│ └── mod.rs
├── embassy-boot-nrf/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── fmt.rs
│ └── lib.rs
├── embassy-boot-rp/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ └── src/
│ ├── fmt.rs
│ └── lib.rs
├── embassy-boot-stm32/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ └── src/
│ ├── fmt.rs
│ └── lib.rs
├── embassy-embedded-hal/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── adapter/
│ │ ├── blocking_async.rs
│ │ ├── mod.rs
│ │ └── yielding_async.rs
│ ├── flash/
│ │ ├── concat_flash.rs
│ │ ├── mem_flash.rs
│ │ ├── mod.rs
│ │ └── partition/
│ │ ├── asynch.rs
│ │ ├── blocking.rs
│ │ └── mod.rs
│ ├── lib.rs
│ └── shared_bus/
│ ├── asynch/
│ │ ├── i2c.rs
│ │ ├── mod.rs
│ │ └── spi.rs
│ ├── blocking/
│ │ ├── i2c.rs
│ │ ├── mod.rs
│ │ └── spi.rs
│ └── mod.rs
├── embassy-executor/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── build_common.rs
│ ├── gen_config.py
│ ├── src/
│ │ ├── fmt.rs
│ │ ├── lib.rs
│ │ ├── metadata.rs
│ │ ├── platform/
│ │ │ ├── avr.rs
│ │ │ ├── cortex_ar.rs
│ │ │ ├── cortex_m.rs
│ │ │ ├── riscv32.rs
│ │ │ ├── spin.rs
│ │ │ ├── std.rs
│ │ │ └── wasm.rs
│ │ ├── raw/
│ │ │ ├── deadline.rs
│ │ │ ├── mod.rs
│ │ │ ├── run_queue.rs
│ │ │ ├── state_atomics.rs
│ │ │ ├── state_atomics_arm.rs
│ │ │ ├── state_critical_section.rs
│ │ │ ├── trace.rs
│ │ │ ├── util.rs
│ │ │ ├── waker.rs
│ │ │ └── waker_turbo.rs
│ │ └── spawner.rs
│ └── tests/
│ ├── test.rs
│ ├── ui/
│ │ ├── abi.rs
│ │ ├── abi.stderr
│ │ ├── bad_return.rs
│ │ ├── bad_return.stderr
│ │ ├── bad_return_impl_future.rs
│ │ ├── bad_return_impl_future.stderr
│ │ ├── bad_return_impl_future_nightly.rs
│ │ ├── bad_return_impl_future_nightly.stderr
│ │ ├── generics.rs
│ │ ├── generics.stderr
│ │ ├── impl_trait.rs
│ │ ├── impl_trait.stderr
│ │ ├── impl_trait_nested.rs
│ │ ├── impl_trait_nested.stderr
│ │ ├── impl_trait_static.rs
│ │ ├── impl_trait_static.stderr
│ │ ├── nonstatic_ref_anon.rs
│ │ ├── nonstatic_ref_anon.stderr
│ │ ├── nonstatic_ref_anon_nested.rs
│ │ ├── nonstatic_ref_anon_nested.stderr
│ │ ├── nonstatic_ref_elided.rs
│ │ ├── nonstatic_ref_elided.stderr
│ │ ├── nonstatic_ref_generic.rs
│ │ ├── nonstatic_ref_generic.stderr
│ │ ├── nonstatic_struct_anon.rs
│ │ ├── nonstatic_struct_anon.stderr
│ │ ├── nonstatic_struct_elided.rs
│ │ ├── nonstatic_struct_elided.stderr
│ │ ├── nonstatic_struct_generic.rs
│ │ ├── nonstatic_struct_generic.stderr
│ │ ├── not_async.rs
│ │ ├── not_async.stderr
│ │ ├── return_impl_future_nonsend.rs
│ │ ├── return_impl_future_nonsend.stderr
│ │ ├── return_impl_send.rs
│ │ ├── return_impl_send.stderr
│ │ ├── return_impl_send_nightly.rs
│ │ ├── return_impl_send_nightly.stderr
│ │ ├── self.rs
│ │ ├── self.stderr
│ │ ├── self_ref.rs
│ │ ├── self_ref.stderr
│ │ ├── spawn_nonsend.rs
│ │ ├── spawn_nonsend.stderr
│ │ ├── task_safety_attribute.rs
│ │ ├── type_error.rs
│ │ ├── type_error.stderr
│ │ ├── unsafe_op_in_unsafe_task.rs
│ │ ├── unsafe_op_in_unsafe_task.stderr
│ │ ├── where_clause.rs
│ │ └── where_clause.stderr
│ └── ui.rs
├── embassy-executor-macros/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── lib.rs
│ ├── macros/
│ │ ├── main.rs
│ │ ├── mod.rs
│ │ └── task.rs
│ └── util.rs
├── embassy-executor-timer-queue/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── embassy-futures/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── block_on.rs
│ ├── fmt.rs
│ ├── join.rs
│ ├── lib.rs
│ ├── select.rs
│ └── yield_now.rs
├── embassy-hal-internal/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── build_common.rs
│ └── src/
│ ├── atomic_ring_buffer.rs
│ ├── drop.rs
│ ├── fmt.rs
│ ├── interrupt.rs
│ ├── lib.rs
│ ├── macros.rs
│ ├── peripheral.rs
│ └── ratio.rs
├── embassy-imxrt/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── chips/
│ │ ├── mimxrt633s.rs
│ │ └── mimxrt685s.rs
│ ├── clocks.rs
│ ├── crc.rs
│ ├── dma.rs
│ ├── flexcomm/
│ │ ├── mod.rs
│ │ ├── spi.rs
│ │ └── uart.rs
│ ├── fmt.rs
│ ├── gpio.rs
│ ├── iopctl.rs
│ ├── lib.rs
│ ├── rng.rs
│ └── time_driver.rs
├── embassy-mcxa/
│ ├── .gitignore
│ ├── Cargo.toml
│ ├── DEVGUIDE.md
│ ├── README.md
│ └── src/
│ ├── adc.rs
│ ├── cdog.rs
│ ├── chips/
│ │ ├── mcxa2xx.rs
│ │ ├── mcxa5xx.rs
│ │ └── mod.rs
│ ├── clkout.rs
│ ├── clocks/
│ │ ├── config.rs
│ │ ├── gate.rs
│ │ ├── mod.rs
│ │ ├── operator.rs
│ │ ├── periph_helpers/
│ │ │ ├── mcxa2xx.rs
│ │ │ ├── mcxa5xx.rs
│ │ │ └── mod.rs
│ │ ├── sleep.rs
│ │ └── types.rs
│ ├── config.rs
│ ├── crc.rs
│ ├── ctimer/
│ │ ├── capture.rs
│ │ ├── mod.rs
│ │ └── pwm.rs
│ ├── dma.rs
│ ├── executor.rs
│ ├── flash.rs
│ ├── gpio.rs
│ ├── i2c/
│ │ ├── controller.rs
│ │ ├── mod.rs
│ │ └── target.rs
│ ├── i3c/
│ │ ├── controller.rs
│ │ └── mod.rs
│ ├── inputmux.rs
│ ├── lib.rs
│ ├── lpuart/
│ │ ├── bbq.rs
│ │ ├── blocking.rs
│ │ ├── buffered.rs
│ │ ├── dma.rs
│ │ └── mod.rs
│ ├── ostimer.rs
│ ├── perf_counters.rs
│ ├── reset_reason.rs
│ ├── rtc/
│ │ ├── mcxa2xx.rs
│ │ ├── mcxa5xx.rs
│ │ └── mod.rs
│ ├── spi/
│ │ ├── controller.rs
│ │ └── mod.rs
│ ├── trng.rs
│ └── wwdt.rs
├── embassy-microchip/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── fmt.rs
│ ├── gpio.rs
│ ├── i2c.rs
│ ├── lib.rs
│ ├── pwm.rs
│ ├── tach.rs
│ ├── time_driver.rs
│ └── uart.rs
├── embassy-mspm0/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── build_common.rs
│ └── src/
│ ├── adc.rs
│ ├── dma.rs
│ ├── fmt.rs
│ ├── gpio.rs
│ ├── i2c.rs
│ ├── i2c_target.rs
│ ├── lib.rs
│ ├── macros.rs
│ ├── mathacl.rs
│ ├── time_driver.rs
│ ├── timer.rs
│ ├── trng.rs
│ ├── uart/
│ │ ├── buffered.rs
│ │ └── mod.rs
│ └── wwdt.rs
├── embassy-net/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── dns.rs
│ ├── driver_util.rs
│ ├── fmt.rs
│ ├── icmp.rs
│ ├── lib.rs
│ ├── raw.rs
│ ├── tcp.rs
│ ├── time.rs
│ └── udp.rs
├── embassy-net-adin1110/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── crc32.rs
│ ├── crc8.rs
│ ├── fmt.rs
│ ├── lib.rs
│ ├── mdio.rs
│ ├── phy.rs
│ └── regs.rs
├── embassy-net-driver/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── embassy-net-driver-channel/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── fmt.rs
│ └── lib.rs
├── embassy-net-enc28j60/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── bank0.rs
│ ├── bank1.rs
│ ├── bank2.rs
│ ├── bank3.rs
│ ├── common.rs
│ ├── fmt.rs
│ ├── header.rs
│ ├── lib.rs
│ ├── macros.rs
│ ├── phy.rs
│ └── traits.rs
├── embassy-net-esp-hosted/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── control.rs
│ ├── esp_hosted_config.proto
│ ├── fmt.rs
│ ├── iface.rs
│ ├── ioctl.rs
│ ├── lib.rs
│ └── proto.rs
├── embassy-net-nrf91/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── context.rs
│ ├── fmt.rs
│ └── lib.rs
├── embassy-net-ppp/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── fmt.rs
│ └── lib.rs
├── embassy-net-tuntap/
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── embassy-net-wiznet/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── chip/
│ │ ├── mod.rs
│ │ ├── w5100s.rs
│ │ ├── w5500.rs
│ │ ├── w6100.rs
│ │ └── w6300.rs
│ ├── device.rs
│ └── lib.rs
├── embassy-nrf/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── buffered_uarte/
│ │ ├── mod.rs
│ │ ├── v1.rs
│ │ └── v2.rs
│ ├── chips/
│ │ ├── nrf51.rs
│ │ ├── nrf52805.rs
│ │ ├── nrf52810.rs
│ │ ├── nrf52811.rs
│ │ ├── nrf52820.rs
│ │ ├── nrf52832.rs
│ │ ├── nrf52833.rs
│ │ ├── nrf52840.rs
│ │ ├── nrf5340_app.rs
│ │ ├── nrf5340_net.rs
│ │ ├── nrf54l05_app.rs
│ │ ├── nrf54l10_app.rs
│ │ ├── nrf54l15_app.rs
│ │ ├── nrf54lm20_app.rs
│ │ ├── nrf9120.rs
│ │ └── nrf9160.rs
│ ├── cracen.rs
│ ├── cryptocell_rng.rs
│ ├── egu.rs
│ ├── embassy_net_802154_driver.rs
│ ├── fmt.rs
│ ├── gpio.rs
│ ├── gpiote.rs
│ ├── i2s.rs
│ ├── ipc.rs
│ ├── lib.rs
│ ├── nfct.rs
│ ├── nvmc.rs
│ ├── pdm.rs
│ ├── power.rs
│ ├── ppi/
│ │ ├── dppi.rs
│ │ ├── mod.rs
│ │ └── ppi.rs
│ ├── pwm.rs
│ ├── qdec.rs
│ ├── qspi.rs
│ ├── radio/
│ │ ├── ieee802154.rs
│ │ └── mod.rs
│ ├── reset.rs
│ ├── rng.rs
│ ├── rramc.rs
│ ├── rtc.rs
│ ├── saadc.rs
│ ├── spim.rs
│ ├── spis.rs
│ ├── temp.rs
│ ├── time_driver.rs
│ ├── timer.rs
│ ├── twim.rs
│ ├── twis.rs
│ ├── uarte.rs
│ ├── usb/
│ │ ├── mod.rs
│ │ └── vbus_detect.rs
│ ├── util.rs
│ └── wdt.rs
├── embassy-nxp/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── build.rs
│ ├── build_common.rs
│ └── src/
│ ├── chips/
│ │ ├── lpc55.rs
│ │ ├── mimxrt1011.rs
│ │ └── mimxrt1062.rs
│ ├── dma/
│ │ └── lpc55.rs
│ ├── dma.rs
│ ├── fmt.rs
│ ├── gpio/
│ │ ├── lpc55.rs
│ │ └── rt1xxx.rs
│ ├── gpio.rs
│ ├── iomuxc.rs
│ ├── lib.rs
│ ├── pint.rs
│ ├── pwm/
│ │ └── lpc55.rs
│ ├── pwm.rs
│ ├── sct.rs
│ ├── time_driver/
│ │ ├── pit.rs
│ │ └── rtc.rs
│ ├── usart/
│ │ └── lpc55.rs
│ └── usart.rs
├── embassy-rp/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── LICENSE-APACHE
│ ├── LICENSE-MIT
│ ├── README.md
│ ├── build.rs
│ ├── funcsel.txt
│ ├── link-rp.x.in
│ └── src/
│ ├── adc.rs
│ ├── aon_timer/
│ │ └── mod.rs
│ ├── block.rs
│ ├── bootsel.rs
│ ├── clocks.rs
│ ├── critical_section_impl.rs
│ ├── datetime/
│ │ ├── datetime_chrono.rs
│ │ ├── datetime_no_deps.rs
│ │ ├── epoch.rs
│ │ └── mod.rs
│ ├── dma.rs
│ ├── executor.rs
│ ├── flash.rs
│ ├── float/
│ │ ├── add_sub.rs
│ │ ├── cmp.rs
│ │ ├── conv.rs
│ │ ├── div.rs
│ │ ├── functions.rs
│ │ ├── mod.rs
│ │ └── mul.rs
│ ├── fmt.rs
│ ├── gpio.rs
│ ├── i2c.rs
│ ├── i2c_slave.rs
│ ├── intrinsics.rs
│ ├── lib.rs
│ ├── multicore.rs
│ ├── otp.rs
│ ├── pio/
│ │ ├── instr.rs
│ │ └── mod.rs
│ ├── pio_programs/
│ │ ├── clk.rs
│ │ ├── clock_divider.rs
│ │ ├── hd44780.rs
│ │ ├── i2s.rs
│ │ ├── mod.rs
│ │ ├── onewire.rs
│ │ ├── pwm.rs
│ │ ├── rotary_encoder.rs
│ │ ├── spi.rs
│ │ ├── stepper.rs
│ │ ├── uart.rs
│ │ └── ws2812.rs
│ ├── psram.rs
│ ├── pwm.rs
│ ├── qmi_cs1.rs
│ ├── relocate.rs
│ ├── reset.rs
│ ├── rom_data/
│ │ ├── mod.rs
│ │ ├── rp2040.rs
│ │ └── rp235x.rs
│ ├── rtc/
│ │ ├── conversions.rs
│ │ ├── filter.rs
│ │ └── mod.rs
│ ├── spi.rs
│ ├── spinlock.rs
│ ├── spinlock_mutex.rs
│ ├── time_driver.rs
│ ├── trng.rs
│ ├── uart/
│ │ ├── buffered.rs
│ │ └── mod.rs
│ ├── usb.rs
│ └── watchdog.rs
├── embassy-stm32/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── build_common.rs
│ └── src/
│ ├── adc/
│ │ ├── adc4.rs
│ │ ├── c0.rs
│ │ ├── f1.rs
│ │ ├── f3.rs
│ │ ├── f3_v1_1.rs
│ │ ├── g4.rs
│ │ ├── injected.rs
│ │ ├── mod.rs
│ │ ├── ringbuffered.rs
│ │ ├── v1.rs
│ │ ├── v2.rs
│ │ ├── v3.rs
│ │ ├── v4.rs
│ │ └── watchdog_v1.rs
│ ├── aes/
│ │ └── mod.rs
│ ├── backup_sram.rs
│ ├── can/
│ │ ├── bxcan/
│ │ │ ├── filter.rs
│ │ │ ├── mod.rs
│ │ │ └── registers.rs
│ │ ├── common.rs
│ │ ├── enums.rs
│ │ ├── fd/
│ │ │ ├── config.rs
│ │ │ ├── filter.rs
│ │ │ ├── message_ram/
│ │ │ │ ├── common.rs
│ │ │ │ ├── enums.rs
│ │ │ │ ├── extended_filter.rs
│ │ │ │ ├── generic.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── rxfifo_element.rs
│ │ │ │ ├── standard_filter.rs
│ │ │ │ ├── txbuffer_element.rs
│ │ │ │ └── txevent_element.rs
│ │ │ ├── mod.rs
│ │ │ └── peripheral.rs
│ │ ├── fdcan.rs
│ │ ├── frame.rs
│ │ ├── mod.rs
│ │ └── util.rs
│ ├── comp.rs
│ ├── cordic/
│ │ ├── enums.rs
│ │ ├── errors.rs
│ │ ├── mod.rs
│ │ └── utils.rs
│ ├── cpu.rs
│ ├── crc/
│ │ ├── mod.rs
│ │ ├── v1.rs
│ │ └── v2v3.rs
│ ├── cryp/
│ │ └── mod.rs
│ ├── dac/
│ │ └── mod.rs
│ ├── dcmi.rs
│ ├── dma/
│ │ ├── dma_bdma.rs
│ │ ├── dmamux.rs
│ │ ├── gpdma/
│ │ │ ├── linked_list.rs
│ │ │ ├── mod.rs
│ │ │ └── ringbuffered.rs
│ │ ├── mod.rs
│ │ ├── ringbuffer/
│ │ │ ├── mod.rs
│ │ │ └── tests/
│ │ │ ├── mod.rs
│ │ │ └── prop_test/
│ │ │ ├── mod.rs
│ │ │ ├── reader.rs
│ │ │ └── writer.rs
│ │ ├── util.rs
│ │ └── word.rs
│ ├── dsihost.rs
│ ├── dts/
│ │ ├── mod.rs
│ │ └── tsel.rs
│ ├── eth/
│ │ ├── generic_phy.rs
│ │ ├── mod.rs
│ │ ├── sma/
│ │ │ ├── mod.rs
│ │ │ ├── v1.rs
│ │ │ └── v2.rs
│ │ ├── v1/
│ │ │ ├── mod.rs
│ │ │ ├── rx_desc.rs
│ │ │ └── tx_desc.rs
│ │ └── v2/
│ │ ├── descriptors.rs
│ │ └── mod.rs
│ ├── executor.rs
│ ├── exti/
│ │ ├── blocking.rs
│ │ ├── low_level.rs
│ │ └── mod.rs
│ ├── flash/
│ │ ├── asynch.rs
│ │ ├── c.rs
│ │ ├── common.rs
│ │ ├── eeprom.rs
│ │ ├── f0.rs
│ │ ├── f1f3.rs
│ │ ├── f2.rs
│ │ ├── f4.rs
│ │ ├── f7.rs
│ │ ├── g.rs
│ │ ├── h5.rs
│ │ ├── h50.rs
│ │ ├── h7.rs
│ │ ├── l.rs
│ │ ├── mod.rs
│ │ ├── other.rs
│ │ ├── u0.rs
│ │ └── u5.rs
│ ├── fmc.rs
│ ├── fmt.rs
│ ├── gpio.rs
│ ├── hash/
│ │ └── mod.rs
│ ├── hrtim/
│ │ ├── bridge_converter.rs
│ │ ├── mod.rs
│ │ ├── resonant_converter.rs
│ │ └── traits.rs
│ ├── hsem/
│ │ └── mod.rs
│ ├── hspi/
│ │ ├── enums.rs
│ │ └── mod.rs
│ ├── i2c/
│ │ ├── config.rs
│ │ ├── mod.rs
│ │ ├── v1.rs
│ │ └── v2.rs
│ ├── i2s.rs
│ ├── ipcc.rs
│ ├── lcd.rs
│ ├── lib.rs
│ ├── low_power.rs
│ ├── lptim/
│ │ ├── channel.rs
│ │ ├── mod.rs
│ │ ├── pwm.rs
│ │ └── timer/
│ │ ├── channel_direction.rs
│ │ ├── mod.rs
│ │ └── prescaler.rs
│ ├── ltdc.rs
│ ├── macros.rs
│ ├── opamp.rs
│ ├── ospi/
│ │ ├── enums.rs
│ │ └── mod.rs
│ ├── pka/
│ │ └── mod.rs
│ ├── qspi/
│ │ ├── enums.rs
│ │ └── mod.rs
│ ├── rcc/
│ │ ├── bd.rs
│ │ ├── c0.rs
│ │ ├── f013.rs
│ │ ├── f247.rs
│ │ ├── g0.rs
│ │ ├── g4.rs
│ │ ├── h.rs
│ │ ├── hsi48.rs
│ │ ├── l.rs
│ │ ├── mco.rs
│ │ ├── mod.rs
│ │ ├── n6.rs
│ │ ├── u3.rs
│ │ ├── u5.rs
│ │ └── wba.rs
│ ├── rng.rs
│ ├── rtc/
│ │ ├── datetime.rs
│ │ ├── low_power.rs
│ │ ├── mod.rs
│ │ ├── v2.rs
│ │ └── v3.rs
│ ├── saes/
│ │ └── mod.rs
│ ├── sai/
│ │ └── mod.rs
│ ├── sdmmc/
│ │ ├── mod.rs
│ │ ├── sd.rs
│ │ └── sdio.rs
│ ├── spdifrx/
│ │ └── mod.rs
│ ├── spi/
│ │ └── mod.rs
│ ├── time.rs
│ ├── time_driver/
│ │ ├── gp16.rs
│ │ ├── lptim.rs
│ │ └── mod.rs
│ ├── timer/
│ │ ├── complementary_pwm.rs
│ │ ├── input_capture.rs
│ │ ├── low_level.rs
│ │ ├── mod.rs
│ │ ├── one_pulse.rs
│ │ ├── pwm_input.rs
│ │ ├── qei.rs
│ │ ├── ringbuffered.rs
│ │ └── simple_pwm.rs
│ ├── tsc/
│ │ ├── acquisition_banks.rs
│ │ ├── config.rs
│ │ ├── errors.rs
│ │ ├── io_pin.rs
│ │ ├── mod.rs
│ │ ├── pin_groups.rs
│ │ ├── tsc.rs
│ │ └── types.rs
│ ├── ucpd.rs
│ ├── uid.rs
│ ├── usart/
│ │ ├── buffered.rs
│ │ ├── mod.rs
│ │ └── ringbuffered.rs
│ ├── usb/
│ │ ├── mod.rs
│ │ ├── otg.rs
│ │ └── usb.rs
│ ├── vrefbuf/
│ │ └── mod.rs
│ ├── wdg/
│ │ └── mod.rs
│ └── xspi/
│ ├── enums.rs
│ └── mod.rs
├── embassy-stm32-wpan/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── src/
│ │ ├── lib.rs
│ │ ├── wb55/
│ │ │ ├── channels.rs
│ │ │ ├── cmd.rs
│ │ │ ├── consts.rs
│ │ │ ├── evt.rs
│ │ │ ├── fmt.rs
│ │ │ ├── fus.rs
│ │ │ ├── lhci.rs
│ │ │ ├── mac/
│ │ │ │ ├── commands.rs
│ │ │ │ ├── consts.rs
│ │ │ │ ├── control.rs
│ │ │ │ ├── driver.rs
│ │ │ │ ├── event.rs
│ │ │ │ ├── indications.rs
│ │ │ │ ├── macros.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── opcodes.rs
│ │ │ │ ├── responses.rs
│ │ │ │ ├── runner.rs
│ │ │ │ └── typedefs.rs
│ │ │ ├── mod.rs
│ │ │ ├── shci.rs
│ │ │ ├── sub/
│ │ │ │ ├── ble.rs
│ │ │ │ ├── mac.rs
│ │ │ │ ├── mm.rs
│ │ │ │ ├── mod.rs
│ │ │ │ └── sys.rs
│ │ │ ├── tables.rs
│ │ │ └── unsafe_linked_list.rs
│ │ └── wba/
│ │ ├── RNG_INTEGRATION.md
│ │ ├── bindings.rs
│ │ ├── ble.rs
│ │ ├── context.rs
│ │ ├── error.rs
│ │ ├── gap/
│ │ │ ├── advertiser.rs
│ │ │ ├── connection.rs
│ │ │ ├── mod.rs
│ │ │ ├── scanner.rs
│ │ │ └── types.rs
│ │ ├── gatt/
│ │ │ ├── events.rs
│ │ │ ├── mod.rs
│ │ │ ├── server.rs
│ │ │ └── types.rs
│ │ ├── hci/
│ │ │ ├── command.rs
│ │ │ ├── event.rs
│ │ │ ├── host_if.rs
│ │ │ ├── mod.rs
│ │ │ └── types.rs
│ │ ├── linklayer_plat.rs
│ │ ├── ll_sys/
│ │ │ ├── ll_sys_cs.rs
│ │ │ ├── ll_sys_dp_slp.rs
│ │ │ ├── ll_sys_intf.rs
│ │ │ ├── ll_sys_startup.rs
│ │ │ ├── ll_version.rs
│ │ │ └── mod.rs
│ │ ├── ll_sys_if.rs
│ │ ├── mac_sys_if.rs
│ │ ├── mod.rs
│ │ ├── power_table.rs
│ │ ├── runner.rs
│ │ ├── security/
│ │ │ └── mod.rs
│ │ └── util_seq.rs
│ ├── tl_mbox.x.in
│ ├── tl_mbox_extended_wb1.x.in
│ └── tl_mbox_extended_wbx5.x.in
├── embassy-sync/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── build_common.rs
│ ├── src/
│ │ ├── blocking_mutex/
│ │ │ ├── mod.rs
│ │ │ └── raw.rs
│ │ ├── channel.rs
│ │ ├── fmt.rs
│ │ ├── lazy_lock.rs
│ │ ├── lib.rs
│ │ ├── mutex.rs
│ │ ├── once_lock.rs
│ │ ├── pipe.rs
│ │ ├── priority_channel.rs
│ │ ├── pubsub/
│ │ │ ├── mod.rs
│ │ │ ├── publisher.rs
│ │ │ └── subscriber.rs
│ │ ├── ring_buffer.rs
│ │ ├── rwlock.rs
│ │ ├── semaphore.rs
│ │ ├── signal.rs
│ │ ├── waitqueue/
│ │ │ ├── atomic_waker.rs
│ │ │ ├── atomic_waker_turbo.rs
│ │ │ ├── mod.rs
│ │ │ ├── multi_waker.rs
│ │ │ └── waker_registration.rs
│ │ ├── watch.rs
│ │ └── zerocopy_channel.rs
│ └── tests/
│ ├── ui/
│ │ └── sync_impl/
│ │ ├── lazy_lock_function.rs
│ │ ├── lazy_lock_function.stderr
│ │ ├── lazy_lock_type.rs
│ │ ├── lazy_lock_type.stderr
│ │ ├── once_lock.rs
│ │ └── once_lock.stderr
│ └── ui.rs
├── embassy-time/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── delay.rs
│ ├── driver_mock.rs
│ ├── driver_std.rs
│ ├── driver_wasm.rs
│ ├── duration.rs
│ ├── fmt.rs
│ ├── instant.rs
│ ├── lib.rs
│ └── timer.rs
├── embassy-time-driver/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── gen_tick.py
│ └── src/
│ ├── lib.rs
│ └── tick.rs
├── embassy-time-queue-utils/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ └── src/
│ ├── lib.rs
│ ├── queue_generic.rs
│ └── queue_integrated.rs
├── embassy-usb/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── gen_config.py
│ └── src/
│ ├── builder.rs
│ ├── class/
│ │ ├── cdc_acm.rs
│ │ ├── cdc_ncm/
│ │ │ ├── embassy_net.rs
│ │ │ └── mod.rs
│ │ ├── cmsis_dap_v2.rs
│ │ ├── dfu/
│ │ │ ├── app_mode.rs
│ │ │ ├── consts.rs
│ │ │ ├── dfu_mode.rs
│ │ │ └── mod.rs
│ │ ├── hid.rs
│ │ ├── midi.rs
│ │ ├── mod.rs
│ │ ├── uac1/
│ │ │ ├── class_codes.rs
│ │ │ ├── mod.rs
│ │ │ ├── speaker.rs
│ │ │ └── terminal_type.rs
│ │ └── web_usb.rs
│ ├── control.rs
│ ├── descriptor.rs
│ ├── descriptor_reader.rs
│ ├── fmt.rs
│ ├── lib.rs
│ ├── msos.rs
│ └── types.rs
├── embassy-usb-dfu/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── src/
│ │ ├── application.rs
│ │ ├── dfu.rs
│ │ ├── fmt.rs
│ │ └── lib.rs
│ └── tests/
│ └── usb_dfu_test.rs
├── embassy-usb-driver/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── embassy-usb-logger/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── embassy-usb-synopsys-otg/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── fmt.rs
│ ├── lib.rs
│ └── otg_v1.rs
├── examples/
│ ├── .cargo/
│ │ └── config.toml
│ ├── boot/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── application/
│ │ │ ├── nrf/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory-bl-nrf91.x
│ │ │ │ ├── memory-bl.x
│ │ │ │ ├── memory-nrf91.x
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── rp/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── stm32f3/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── stm32f7/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── flash-boot.sh
│ │ │ │ ├── memory-bl.x
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── stm32h7/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── flash-boot.sh
│ │ │ │ ├── memory-bl.x
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── stm32l0/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── stm32l1/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── stm32l4/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── stm32wb-dfu/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory.x
│ │ │ │ ├── secrets/
│ │ │ │ │ └── key.sec
│ │ │ │ └── src/
│ │ │ │ └── main.rs
│ │ │ ├── stm32wba-dfu/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory.x
│ │ │ │ ├── secrets/
│ │ │ │ │ └── key.sec
│ │ │ │ └── src/
│ │ │ │ └── main.rs
│ │ │ └── stm32wl/
│ │ │ ├── .cargo/
│ │ │ │ └── config.toml
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── build.rs
│ │ │ ├── memory.x
│ │ │ └── src/
│ │ │ └── bin/
│ │ │ ├── a.rs
│ │ │ └── b.rs
│ │ └── bootloader/
│ │ ├── nrf/
│ │ │ ├── .cargo/
│ │ │ │ └── config.toml
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── build.rs
│ │ │ ├── memory-bm.x
│ │ │ ├── memory-s140.x
│ │ │ ├── memory.x
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── rp/
│ │ │ ├── .cargo/
│ │ │ │ └── config.toml
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── build.rs
│ │ │ ├── memory.x
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── stm32/
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── build.rs
│ │ │ ├── memory.x
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── stm32-dual-bank/
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── build.rs
│ │ │ ├── memory.x
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── stm32wb-dfu/
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── build.rs
│ │ │ ├── memory.x
│ │ │ ├── secrets/
│ │ │ │ └── key.pub.short
│ │ │ └── src/
│ │ │ └── main.rs
│ │ └── stm32wba-dfu/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ ├── secrets/
│ │ │ └── key.pub.short
│ │ └── src/
│ │ └── main.rs
│ ├── lpc55s69/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky_embassy_time.rs
│ │ ├── blinky_nop.rs
│ │ ├── button_executor.rs
│ │ ├── pwm.rs
│ │ ├── usart_async.rs
│ │ └── usart_blocking.rs
│ ├── mcxa2xx/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc-async.rs
│ │ ├── adc-blocking.rs
│ │ ├── adc-temperature.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_async.rs
│ │ ├── capture.rs
│ │ ├── cdog.rs
│ │ ├── clkout.rs
│ │ ├── cpu-clocks.rs
│ │ ├── crc.rs
│ │ ├── dma_mem_to_mem.rs
│ │ ├── dma_scatter_gather_builder.rs
│ │ ├── flash_iap.rs
│ │ ├── hello.rs
│ │ ├── i2c-async.rs
│ │ ├── i2c-blocking.rs
│ │ ├── i2c-dma.rs
│ │ ├── i2c-scan-blocking.rs
│ │ ├── i2c-target-async.rs
│ │ ├── i2c-target-blocking.rs
│ │ ├── i2c-target-dma.rs
│ │ ├── i3c-async.rs
│ │ ├── i3c-blocking.rs
│ │ ├── i3c-dma.rs
│ │ ├── lpuart_bbq_rx.rs
│ │ ├── lpuart_bbq_tx.rs
│ │ ├── lpuart_buffered.rs
│ │ ├── lpuart_dma.rs
│ │ ├── lpuart_polling.rs
│ │ ├── lpuart_ring_buffer.rs
│ │ ├── power-deepsleep-big-jump.rs
│ │ ├── power-deepsleep-gating.rs
│ │ ├── power-deepsleep-gpio-int.rs
│ │ ├── power-deepsleep.rs
│ │ ├── power-wfe-gated.rs
│ │ ├── pwm.rs
│ │ ├── reset-reason.rs
│ │ ├── rtc_alarm.rs
│ │ ├── spi-async.rs
│ │ ├── spi-blocking.rs
│ │ ├── spi-dma.rs
│ │ ├── trng.rs
│ │ ├── wwdt_interrupt.rs
│ │ └── wwdt_reset.rs
│ ├── mcxa5xx/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc-async.rs
│ │ ├── adc-blocking.rs
│ │ ├── adc-temperature.rs
│ │ ├── blinky-firc.rs
│ │ ├── blinky-sosc.rs
│ │ ├── blinky-spll.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_async.rs
│ │ ├── capture.rs
│ │ ├── cdog.rs
│ │ ├── clkout.rs
│ │ ├── crc.rs
│ │ ├── dma_mem_to_mem.rs
│ │ ├── dma_scatter_gather_builder.rs
│ │ ├── hello.rs
│ │ ├── i2c-async.rs
│ │ ├── i2c-blocking.rs
│ │ ├── i2c-dma.rs
│ │ ├── i2c-scan-blocking.rs
│ │ ├── i2c-target-async.rs
│ │ ├── i2c-target-blocking.rs
│ │ ├── i2c-target-dma.rs
│ │ ├── i3c-async.rs
│ │ ├── i3c-blocking.rs
│ │ ├── i3c-dma.rs
│ │ ├── lpuart_bbq_rx.rs
│ │ ├── lpuart_bbq_tx.rs
│ │ ├── lpuart_buffered.rs
│ │ ├── lpuart_dma.rs
│ │ ├── lpuart_polling.rs
│ │ ├── lpuart_ring_buffer.rs
│ │ ├── power-deepsleep-big-jump.rs
│ │ ├── power-deepsleep-gating.rs
│ │ ├── power-deepsleep-gpio-int.rs
│ │ ├── power-deepsleep.rs
│ │ ├── power-wfe-gated.rs
│ │ ├── pwm.rs
│ │ ├── reset-reason.rs
│ │ ├── rtc-alarm.rs
│ │ ├── spi-async.rs
│ │ ├── spi-blocking.rs
│ │ ├── spi-dma.rs
│ │ ├── trng.rs
│ │ ├── wwdt_interrupt.rs
│ │ └── wwdt_reset.rs
│ ├── microchip/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── link_ram.x
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button-async.rs
│ │ ├── button.rs
│ │ ├── i2c-async.rs
│ │ ├── i2c.rs
│ │ ├── pwm.rs
│ │ ├── uart_async.rs
│ │ └── uart_blocking.rs
│ ├── mimxrt1011/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ ├── bin/
│ │ │ ├── blinky.rs
│ │ │ └── button.rs
│ │ └── lib.rs
│ ├── mimxrt1062-evk/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ ├── bin/
│ │ │ ├── blinky.rs
│ │ │ └── button.rs
│ │ └── lib.rs
│ ├── mimxrt6/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ ├── bin/
│ │ │ ├── blinky.rs
│ │ │ ├── button.rs
│ │ │ ├── crc.rs
│ │ │ ├── dma.rs
│ │ │ ├── hello.rs
│ │ │ ├── rng.rs
│ │ │ ├── spi-async.rs
│ │ │ ├── spi.rs
│ │ │ ├── uart-async.rs
│ │ │ └── uart.rs
│ │ └── lib.rs
│ ├── mspm0c1104/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── uart.rs
│ │ └── wwdt.rs
│ ├── mspm0g3507/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── i2c.rs
│ │ ├── i2c_async.rs
│ │ ├── i2c_target.rs
│ │ ├── mathacl_ops.rs
│ │ ├── uart.rs
│ │ ├── uart_buffered.rs
│ │ └── wwdt.rs
│ ├── mspm0g3519/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── uart.rs
│ │ └── wwdt.rs
│ ├── mspm0g5187/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ └── wwdt.rs
│ ├── mspm0l1306/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── i2c.rs
│ │ ├── i2c_async.rs
│ │ ├── i2c_target.rs
│ │ ├── uart.rs
│ │ └── wwdt.rs
│ ├── mspm0l2228/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── trng.rs
│ │ ├── uart.rs
│ │ └── wwdt.rs
│ ├── nrf-rtos-trace/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── rtos_trace.rs
│ ├── nrf51/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── blinky.rs
│ ├── nrf52810/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── saadc_lowpower.rs
│ ├── nrf52840/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── buffered_uart.rs
│ │ ├── channel.rs
│ │ ├── channel_sender_receiver.rs
│ │ ├── egu.rs
│ │ ├── ethernet_enc28j60.rs
│ │ ├── executor_fairness_test.rs
│ │ ├── gpiote_channel.rs
│ │ ├── gpiote_port.rs
│ │ ├── i2s_effect.rs
│ │ ├── i2s_monitor.rs
│ │ ├── i2s_waveform.rs
│ │ ├── ieee802154_receive.rs
│ │ ├── ieee802154_send.rs
│ │ ├── manually_create_executor.rs
│ │ ├── multiprio.rs
│ │ ├── mutex.rs
│ │ ├── nfct.rs
│ │ ├── nvmc.rs
│ │ ├── pdm.rs
│ │ ├── pdm_continuous.rs
│ │ ├── ppi.rs
│ │ ├── pubsub.rs
│ │ ├── pwm.rs
│ │ ├── pwm_double_sequence.rs
│ │ ├── pwm_sequence.rs
│ │ ├── pwm_sequence_ppi.rs
│ │ ├── pwm_sequence_ws2812b.rs
│ │ ├── pwm_servo.rs
│ │ ├── qdec.rs
│ │ ├── qspi.rs
│ │ ├── qspi_lowpower.rs
│ │ ├── raw_spawn.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── saadc.rs
│ │ ├── saadc_continuous.rs
│ │ ├── self_spawn.rs
│ │ ├── self_spawn_current_executor.rs
│ │ ├── sixlowpan.rs
│ │ ├── spim.rs
│ │ ├── spis.rs
│ │ ├── temp.rs
│ │ ├── timer.rs
│ │ ├── twim.rs
│ │ ├── twim_lowpower.rs
│ │ ├── twis.rs
│ │ ├── uart.rs
│ │ ├── uart_idle.rs
│ │ ├── uart_split.rs
│ │ ├── usb_ethernet.rs
│ │ ├── usb_hid_keyboard.rs
│ │ ├── usb_hid_mouse.rs
│ │ ├── usb_serial.rs
│ │ ├── usb_serial_multitask.rs
│ │ ├── usb_serial_winusb.rs
│ │ ├── wdt.rs
│ │ └── wifi_esp_hosted.rs
│ ├── nrf52840-edf/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── basic.rs
│ ├── nrf52840-rtic/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── blinky.rs
│ ├── nrf5340/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── cryptocell_rng.rs
│ │ ├── gpiote_channel.rs
│ │ ├── nrf5340dk_internal_caps.rs
│ │ └── uart.rs
│ ├── nrf54l15/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── buffered_uart.rs
│ │ ├── gpiote_channel.rs
│ │ ├── gpiote_port.rs
│ │ ├── pwm.rs
│ │ ├── rng.rs
│ │ ├── rramc.rs
│ │ ├── rramc_buffered.rs
│ │ ├── saadc.rs
│ │ ├── spim.rs
│ │ ├── temp.rs
│ │ ├── timer.rs
│ │ ├── twim.rs
│ │ ├── twis.rs
│ │ ├── uart.rs
│ │ └── wdt.rs
│ ├── nrf54lm20/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── gpio.rs
│ │ ├── gpiote_channel.rs
│ │ ├── gpiote_port.rs
│ │ └── timer.rs
│ ├── nrf9151/
│ │ ├── ns/
│ │ │ ├── .cargo/
│ │ │ │ └── config.toml
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── build.rs
│ │ │ ├── flash_tfm.sh
│ │ │ ├── memory.x
│ │ │ ├── src/
│ │ │ │ └── bin/
│ │ │ │ ├── blinky.rs
│ │ │ │ └── uart.rs
│ │ │ └── tfm.hex
│ │ └── s/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── cryptocell_rng.rs
│ ├── nrf9160/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── modem_tcp_client.rs
│ ├── rp/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── assets/
│ │ │ └── ferris.raw
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_dma.rs
│ │ ├── assign_resources.rs
│ │ ├── blinky.rs
│ │ ├── blinky_two_channels.rs
│ │ ├── blinky_two_tasks.rs
│ │ ├── button.rs
│ │ ├── debounce.rs
│ │ ├── ethernet_w5500_icmp.rs
│ │ ├── ethernet_w5500_icmp_ping.rs
│ │ ├── ethernet_w5500_multisocket.rs
│ │ ├── ethernet_w5500_tcp_client.rs
│ │ ├── ethernet_w5500_tcp_server.rs
│ │ ├── ethernet_w5500_udp.rs
│ │ ├── ethernet_w55rp20_tcp_server.rs
│ │ ├── flash.rs
│ │ ├── gpio_async.rs
│ │ ├── gpout.rs
│ │ ├── i2c_async.rs
│ │ ├── i2c_async_embassy.rs
│ │ ├── i2c_blocking.rs
│ │ ├── i2c_slave.rs
│ │ ├── interrupt.rs
│ │ ├── multicore.rs
│ │ ├── multiprio.rs
│ │ ├── orchestrate_tasks.rs
│ │ ├── overclock.rs
│ │ ├── overclock_manual.rs
│ │ ├── pio_async.rs
│ │ ├── pio_clk.rs
│ │ ├── pio_dma.rs
│ │ ├── pio_hd44780.rs
│ │ ├── pio_i2s.rs
│ │ ├── pio_i2s_mclk.rs
│ │ ├── pio_onewire.rs
│ │ ├── pio_onewire_parasite.rs
│ │ ├── pio_pwm.rs
│ │ ├── pio_rotary_encoder.rs
│ │ ├── pio_servo.rs
│ │ ├── pio_spi.rs
│ │ ├── pio_spi_async.rs
│ │ ├── pio_stepper.rs
│ │ ├── pio_uart.rs
│ │ ├── pio_ws2812.rs
│ │ ├── pwm.rs
│ │ ├── pwm_input.rs
│ │ ├── rosc.rs
│ │ ├── rtc.rs
│ │ ├── rtc_alarm.rs
│ │ ├── shared_bus.rs
│ │ ├── sharing.rs
│ │ ├── spi.rs
│ │ ├── spi_async.rs
│ │ ├── spi_display.rs
│ │ ├── spi_gc9a01.rs
│ │ ├── spi_sdmmc.rs
│ │ ├── uart.rs
│ │ ├── uart_buffered_split.rs
│ │ ├── uart_r503.rs
│ │ ├── uart_unidir.rs
│ │ ├── usb_ethernet.rs
│ │ ├── usb_hid_keyboard.rs
│ │ ├── usb_hid_mouse.rs
│ │ ├── usb_logger.rs
│ │ ├── usb_midi.rs
│ │ ├── usb_raw.rs
│ │ ├── usb_raw_bulk.rs
│ │ ├── usb_serial.rs
│ │ ├── usb_serial_with_handler.rs
│ │ ├── usb_serial_with_logger.rs
│ │ ├── usb_webusb.rs
│ │ ├── watchdog.rs
│ │ ├── wifi_ap_tcp_server.rs
│ │ ├── wifi_blinky.rs
│ │ ├── wifi_scan.rs
│ │ ├── wifi_tcp_server.rs
│ │ ├── wifi_webrequest.rs
│ │ └── zerocopy.rs
│ ├── rp235x/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── assets/
│ │ │ └── ferris.raw
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_dma.rs
│ │ ├── aon_timer_async.rs
│ │ ├── assign_resources.rs
│ │ ├── blinky.rs
│ │ ├── blinky_two_channels.rs
│ │ ├── blinky_two_tasks.rs
│ │ ├── blinky_wifi.rs
│ │ ├── blinky_wifi_pico_plus_2.rs
│ │ ├── button.rs
│ │ ├── debounce.rs
│ │ ├── ethernet_w5500_icmp.rs
│ │ ├── ethernet_w5500_icmp_ping.rs
│ │ ├── ethernet_w5500_multisocket.rs
│ │ ├── ethernet_w5500_tcp_client.rs
│ │ ├── ethernet_w5500_tcp_server.rs
│ │ ├── ethernet_w5500_udp.rs
│ │ ├── ethernet_w6300_udp.rs
│ │ ├── flash.rs
│ │ ├── gpio_async.rs
│ │ ├── gpout.rs
│ │ ├── i2c_async.rs
│ │ ├── i2c_async_embassy.rs
│ │ ├── i2c_blocking.rs
│ │ ├── i2c_slave.rs
│ │ ├── interrupt.rs
│ │ ├── multicore.rs
│ │ ├── multicore_stack_overflow.rs
│ │ ├── multiprio.rs
│ │ ├── otp.rs
│ │ ├── overclock.rs
│ │ ├── pio_async.rs
│ │ ├── pio_dma.rs
│ │ ├── pio_hd44780.rs
│ │ ├── pio_i2s.rs
│ │ ├── pio_i2s_rx.rs
│ │ ├── pio_onewire.rs
│ │ ├── pio_onewire_parasite.rs
│ │ ├── pio_pwm.rs
│ │ ├── pio_rotary_encoder.rs
│ │ ├── pio_rotary_encoder_rxf.rs
│ │ ├── pio_servo.rs
│ │ ├── pio_stepper.rs
│ │ ├── pio_uart.rs
│ │ ├── pio_ws2812.rs
│ │ ├── psram.rs
│ │ ├── pwm.rs
│ │ ├── pwm_input.rs
│ │ ├── pwm_tb6612fng_motor_driver.rs
│ │ ├── rosc.rs
│ │ ├── shared_bus.rs
│ │ ├── sharing.rs
│ │ ├── spi.rs
│ │ ├── spi_async.rs
│ │ ├── spi_display.rs
│ │ ├── spi_sdmmc.rs
│ │ ├── trng.rs
│ │ ├── uart.rs
│ │ ├── uart_buffered_split.rs
│ │ ├── uart_r503.rs
│ │ ├── uart_unidir.rs
│ │ ├── usb_hid_keyboard.rs
│ │ ├── usb_webusb.rs
│ │ ├── watchdog.rs
│ │ └── zerocopy.rs
│ ├── std/
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── src/
│ │ │ ├── bin/
│ │ │ │ ├── net.rs
│ │ │ │ ├── net_dns.rs
│ │ │ │ ├── net_ppp.rs
│ │ │ │ ├── net_udp.rs
│ │ │ │ ├── serial.rs
│ │ │ │ ├── tcp_accept.rs
│ │ │ │ ├── tick.rs
│ │ │ │ └── tick_cancel.rs
│ │ │ └── serial_port.rs
│ │ └── tap.sh
│ ├── stm32c0/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_ring_buffered_timer.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ └── rtc.rs
│ ├── stm32f0/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc-watchdog.rs
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── button_controlled_blink.rs
│ │ ├── button_exti.rs
│ │ ├── hello.rs
│ │ ├── i2c_master.rs
│ │ ├── i2c_slave_async.rs
│ │ ├── i2c_slave_blocking.rs
│ │ ├── multiprio.rs
│ │ └── wdg.rs
│ ├── stm32f072/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── i2c_loopback_test_async.rs
│ ├── stm32f1/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── can.rs
│ │ ├── hello.rs
│ │ ├── input_capture.rs
│ │ ├── pwm_input.rs
│ │ └── usb_serial.rs
│ ├── stm32f105/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── usb_serial.rs
│ ├── stm32f107/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── eth.rs
│ ├── stm32f2/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── pll.rs
│ ├── stm32f3/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_events.rs
│ │ ├── button_exti.rs
│ │ ├── flash.rs
│ │ ├── hello.rs
│ │ ├── multiprio.rs
│ │ ├── spi_dma.rs
│ │ ├── tsc_blocking.rs
│ │ ├── tsc_multipin.rs
│ │ ├── usart_dma.rs
│ │ └── usb_serial.rs
│ ├── stm32f334/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── button.rs
│ │ ├── hello.rs
│ │ ├── hrtim.rs
│ │ ├── opamp.rs
│ │ └── pwm.rs
│ ├── stm32f4/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_dma.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── can.rs
│ │ ├── dac.rs
│ │ ├── eth.rs
│ │ ├── eth_compliance_test.rs
│ │ ├── eth_w5500.rs
│ │ ├── flash.rs
│ │ ├── flash_async.rs
│ │ ├── hello.rs
│ │ ├── i2c.rs
│ │ ├── i2c_async.rs
│ │ ├── i2c_comparison.rs
│ │ ├── i2c_master_test_blocking.rs
│ │ ├── i2c_slave_async.rs
│ │ ├── i2c_slave_blocking.rs
│ │ ├── i2s_dma.rs
│ │ ├── input_capture.rs
│ │ ├── mco.rs
│ │ ├── multiprio.rs
│ │ ├── pwm.rs
│ │ ├── pwm_complementary.rs
│ │ ├── pwm_input.rs
│ │ ├── rtc.rs
│ │ ├── sdmmc.rs
│ │ ├── spi.rs
│ │ ├── spi_dma.rs
│ │ ├── usart.rs
│ │ ├── usart_buffered.rs
│ │ ├── usart_dma.rs
│ │ ├── usb_ethernet.rs
│ │ ├── usb_hid_keyboard.rs
│ │ ├── usb_hid_mouse.rs
│ │ ├── usb_raw.rs
│ │ ├── usb_serial.rs
│ │ ├── usb_uac_speaker.rs
│ │ ├── wdt.rs
│ │ ├── ws2812_pwm.rs
│ │ └── ws2812_spi.rs
│ ├── stm32f401/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── i2c_loopback_test_async.rs
│ ├── stm32f469/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── dsi_bsp.rs
│ ├── stm32f7/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── can.rs
│ │ ├── cryp.rs
│ │ ├── eth.rs
│ │ ├── flash.rs
│ │ ├── hash.rs
│ │ ├── hello.rs
│ │ ├── pwm.rs
│ │ ├── pwm_ringbuffer.rs
│ │ ├── qspi.rs
│ │ ├── sdmmc.rs
│ │ ├── usart_dma.rs
│ │ └── usb_serial.rs
│ ├── stm32g0/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_dma.rs
│ │ ├── adc_oversampling.rs
│ │ ├── adc_ring_buffered_timer.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── flash.rs
│ │ ├── flash_async.rs
│ │ ├── hf_timer.rs
│ │ ├── i2c_async.rs
│ │ ├── input_capture.rs
│ │ ├── onewire_ds18b20.rs
│ │ ├── pwm_complementary.rs
│ │ ├── pwm_input.rs
│ │ ├── rtc.rs
│ │ ├── spi_neopixel.rs
│ │ ├── usart.rs
│ │ ├── usart_buffered.rs
│ │ ├── usart_dma.rs
│ │ └── usb_serial.rs
│ ├── stm32g4/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_differential.rs
│ │ ├── adc_dma.rs
│ │ ├── adc_injected_and_regular.rs
│ │ ├── adc_oversampling.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── can.rs
│ │ ├── i2c_slave.rs
│ │ ├── i2s.rs
│ │ ├── pll.rs
│ │ ├── pwm.rs
│ │ ├── usb_c_pd.rs
│ │ └── usb_serial.rs
│ ├── stm32g474/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── comp.rs
│ │ ├── flash_async.rs
│ │ ├── hrtim.rs
│ │ ├── hrtim_master.rs
│ │ └── pwm_input_async.rs
│ ├── stm32h5/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_dma.rs
│ │ ├── backup_sram.rs
│ │ ├── blinky.rs
│ │ ├── button_exti.rs
│ │ ├── can.rs
│ │ ├── cordic.rs
│ │ ├── dts.rs
│ │ ├── eth.rs
│ │ ├── i2c.rs
│ │ ├── mco.rs
│ │ ├── rng.rs
│ │ ├── sai.rs
│ │ ├── usart.rs
│ │ ├── usart_dma.rs
│ │ ├── usart_split.rs
│ │ ├── usb_c_pd.rs
│ │ ├── usb_serial.rs
│ │ ├── usb_uac_speaker.rs
│ │ └── wifi_scan.rs
│ ├── stm32h7/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_dma.rs
│ │ ├── blinky.rs
│ │ ├── button_exti.rs
│ │ ├── camera.rs
│ │ ├── can.rs
│ │ ├── dac.rs
│ │ ├── dac_dma.rs
│ │ ├── eth.rs
│ │ ├── eth_client.rs
│ │ ├── eth_client_mii.rs
│ │ ├── flash.rs
│ │ ├── flash_async.rs
│ │ ├── fmc.rs
│ │ ├── i2c.rs
│ │ ├── i2c_shared.rs
│ │ ├── low_level_timer_api.rs
│ │ ├── mco.rs
│ │ ├── multiprio.rs
│ │ ├── pwm.rs
│ │ ├── qspi_mdma.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── sai.rs
│ │ ├── sdmmc.rs
│ │ ├── signal.rs
│ │ ├── spi.rs
│ │ ├── spi_bdma.rs
│ │ ├── spi_dma.rs
│ │ ├── usart.rs
│ │ ├── usart_dma.rs
│ │ ├── usart_split.rs
│ │ ├── usb_serial.rs
│ │ └── wdg.rs
│ ├── stm32h723/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── spdifrx.rs
│ ├── stm32h735/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── ltdc.rs
│ ├── stm32h742/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── qspi.rs
│ ├── stm32h755cm4/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── intercore.rs
│ ├── stm32h755cm7/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── intercore.rs
│ ├── stm32h7b0/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── ospi_memory_mapped.rs
│ ├── stm32h7rs/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button_exti.rs
│ │ ├── can.rs
│ │ ├── eth.rs
│ │ ├── i2c.rs
│ │ ├── mco.rs
│ │ ├── multiprio.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── signal.rs
│ │ ├── spi.rs
│ │ ├── spi_dma.rs
│ │ ├── usart.rs
│ │ ├── usart_dma.rs
│ │ ├── usart_split.rs
│ │ ├── usb_serial.rs
│ │ └── xspi_memory_mapped.rs
│ ├── stm32l0/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── dds.rs
│ │ ├── eeprom.rs
│ │ ├── flash.rs
│ │ ├── raw_spawn.rs
│ │ ├── spi.rs
│ │ ├── tsc_async.rs
│ │ ├── tsc_blocking.rs
│ │ ├── tsc_multipin.rs
│ │ ├── usart_dma.rs
│ │ ├── usart_irq.rs
│ │ └── usb_serial.rs
│ ├── stm32l1/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── eeprom.rs
│ │ ├── flash.rs
│ │ ├── spi.rs
│ │ ├── usart.rs
│ │ └── usb_serial.rs
│ ├── stm32l4/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_dma.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── can.rs
│ │ ├── dac.rs
│ │ ├── dac_dma.rs
│ │ ├── flash_async.rs
│ │ ├── i2c.rs
│ │ ├── i2c_blocking_async.rs
│ │ ├── i2c_dma.rs
│ │ ├── mco.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── spe_adin1110_http_server.rs
│ │ ├── spi.rs
│ │ ├── spi_blocking_async.rs
│ │ ├── spi_dma.rs
│ │ ├── tsc_async.rs
│ │ ├── tsc_blocking.rs
│ │ ├── tsc_multipin.rs
│ │ ├── usart.rs
│ │ ├── usart_dma.rs
│ │ └── usb_serial.rs
│ ├── stm32l4-rtic/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── blinky_timer_interrupt.rs
│ │ └── button_exti.rs
│ ├── stm32l432/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── qspi_mmap.rs
│ ├── stm32l5/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── button_exti.rs
│ │ ├── rng.rs
│ │ ├── usb_ethernet.rs
│ │ ├── usb_hid_mouse.rs
│ │ └── usb_serial.rs
│ ├── stm32l5-lp/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── stop.rs
│ ├── stm32n6/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── crc.rs
│ │ ├── hash.rs
│ │ ├── xspi_flash.rs
│ │ └── xspi_psram.rs
│ ├── stm32u0/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── crc.rs
│ │ ├── dac.rs
│ │ ├── flash.rs
│ │ ├── i2c.rs
│ │ ├── lcd.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── spi.rs
│ │ ├── usart.rs
│ │ ├── usb_serial.rs
│ │ └── wdt.rs
│ ├── stm32u3/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button_exti.rs
│ │ ├── mco.rs
│ │ ├── rtc.rs
│ │ └── usb_serial.rs
│ ├── stm32u5/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── boot.rs
│ │ ├── flash.rs
│ │ ├── hspi_memory_mapped.rs
│ │ ├── i2c.rs
│ │ ├── ltdc.rs
│ │ ├── rng.rs
│ │ ├── tsc.rs
│ │ ├── usb_hs_serial.rs
│ │ └── usb_serial.rs
│ ├── stm32wb/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button_exti.rs
│ │ ├── eddystone_beacon.rs
│ │ ├── fus_update.rs
│ │ ├── gatt_server.rs
│ │ ├── mac_ffd.rs
│ │ ├── mac_ffd_net.rs
│ │ ├── mac_rfd.rs
│ │ ├── tl_mbox.rs
│ │ ├── tl_mbox_ble.rs
│ │ └── tl_mbox_mac.rs
│ ├── stm32wba/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_ring_buffered.rs
│ │ ├── aes_cbc.rs
│ │ ├── aes_ccm.rs
│ │ ├── aes_ctr.rs
│ │ ├── aes_ecb.rs
│ │ ├── aes_gcm.rs
│ │ ├── aes_gmac.rs
│ │ ├── ble_advertiser.rs
│ │ ├── ble_central.rs
│ │ ├── ble_gatt_server.rs
│ │ ├── ble_peripheral_connect.rs
│ │ ├── ble_scanner.rs
│ │ ├── ble_secure.rs
│ │ ├── blinky.rs
│ │ ├── button_exti.rs
│ │ ├── device_info.rs
│ │ ├── flash.rs
│ │ ├── mac_ffd.rs
│ │ ├── pka_ecdh.rs
│ │ ├── pka_ecdsa_sign.rs
│ │ ├── pka_ecdsa_verify.rs
│ │ ├── pka_rsa.rs
│ │ ├── pka_rsa_crt.rs
│ │ ├── pka_rsa_keygen.rs
│ │ ├── pwm.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── saes_ecb.rs
│ │ └── saes_gcm.rs
│ ├── stm32wba-lp/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── button_exti.rs
│ ├── stm32wba6/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README_PCM.md
│ │ ├── build.rs
│ │ ├── convert_wav.py
│ │ ├── convert_wav.sh
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_ring_buffered.rs
│ │ ├── aes_cbc.rs
│ │ ├── aes_ccm.rs
│ │ ├── aes_ctr.rs
│ │ ├── aes_ecb.rs
│ │ ├── aes_gcm.rs
│ │ ├── aes_gmac.rs
│ │ ├── ble_advertiser.rs
│ │ ├── ble_central.rs
│ │ ├── ble_gatt_server.rs
│ │ ├── ble_peripheral_connect.rs
│ │ ├── ble_scanner.rs
│ │ ├── ble_secure.rs
│ │ ├── blinky.rs
│ │ ├── button_exti.rs
│ │ ├── comp.rs
│ │ ├── comp_window.rs
│ │ ├── device_info.rs
│ │ ├── flash.rs
│ │ ├── mac_ffd.rs
│ │ ├── pka_ecdh.rs
│ │ ├── pka_ecdsa_sign.rs
│ │ ├── pka_ecdsa_verify.rs
│ │ ├── pka_rsa.rs
│ │ ├── pka_rsa_crt.rs
│ │ ├── pka_rsa_keygen.rs
│ │ ├── pwm.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── saes_ecb.rs
│ │ ├── saes_gcm.rs
│ │ ├── sdmmc_sai.rs
│ │ ├── usb_hs_serial.rs
│ │ └── wwdg.rs
│ ├── stm32wba6-lp/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── button_exti.rs
│ ├── stm32wl/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── flash.rs
│ │ ├── random.rs
│ │ ├── rtc.rs
│ │ └── uart_async.rs
│ ├── stm32wl55cm0p/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── intercore.rs
│ ├── stm32wl55cm0p-lp/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── intercore.rs
│ ├── stm32wl55cm4/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── intercore.rs
│ ├── stm32wl55cm4-lp/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── intercore.rs
│ ├── stm32wle5-lp/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── src/
│ │ │ └── bin/
│ │ │ ├── adc.rs
│ │ │ ├── blinky.rs
│ │ │ ├── button_exti.rs
│ │ │ └── i2c.rs
│ │ └── stm32wle5.code-workspace
│ └── wasm/
│ ├── Cargo.toml
│ ├── README.md
│ ├── index.html
│ └── src/
│ └── lib.rs
├── fmtall.sh
├── release/
│ ├── bump-dependency.sh
│ └── release.toml
├── rust-toolchain-nightly.toml
├── rust-toolchain.toml
├── rustfmt.toml
└── tests/
├── link_ram_cortex_m.x
├── mcxa2xx/
│ ├── .cargo/
│ │ └── config.toml
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── memory.x
│ └── src/
│ └── bin/
│ ├── adc.rs
│ ├── adc_compare.rs
│ ├── cdog.rs
│ ├── crc.rs
│ ├── ctimer_capture.rs
│ ├── dma.rs
│ ├── gpio.rs
│ ├── i2c.rs
│ ├── i3c.rs
│ ├── lpuart.rs
│ ├── pwm.rs
│ ├── rtc_alarm.rs
│ ├── trng.rs
│ └── wwdt_interrupt.rs
├── mspm0/
│ ├── .cargo/
│ │ └── config.toml
│ ├── Cargo.toml
│ ├── build.rs
│ ├── memory_g3507.x
│ ├── memory_g3519.x
│ └── src/
│ └── bin/
│ ├── dma.rs
│ ├── uart.rs
│ └── uart_buffered.rs
├── nrf/
│ ├── .cargo/
│ │ └── config.toml
│ ├── Cargo.toml
│ ├── build.rs
│ ├── gen_test.py
│ ├── memory-nrf51422.x
│ ├── memory-nrf52832.x
│ ├── memory-nrf52833.x
│ ├── memory-nrf52840.x
│ ├── memory-nrf5340.x
│ ├── memory-nrf9160.x
│ └── src/
│ ├── bin/
│ │ ├── buffered_uart.rs
│ │ ├── buffered_uart_full.rs
│ │ ├── buffered_uart_halves.rs
│ │ ├── buffered_uart_spam.rs
│ │ ├── ethernet_enc28j60_perf.rs
│ │ ├── gpio.rs
│ │ ├── gpiote.rs
│ │ ├── spim.rs
│ │ ├── timer.rs
│ │ ├── uart_halves.rs
│ │ ├── uart_split.rs
│ │ └── wifi_esp_hosted_perf.rs
│ └── common.rs
├── perf-client/
│ ├── Cargo.toml
│ └── src/
│ └── lib.rs
├── perf-server/
│ ├── Cargo.toml
│ ├── deploy.sh
│ ├── perf-server.service
│ └── src/
│ └── main.rs
├── riscv32/
│ ├── .cargo/
│ │ └── config.toml
│ ├── Cargo.toml
│ ├── build.rs
│ ├── link.x
│ ├── memory.x
│ └── src/
│ └── bin/
│ └── empty.rs
├── rp/
│ ├── .cargo/
│ │ └── config.toml
│ ├── Cargo.toml
│ ├── build.rs
│ ├── memory.x
│ ├── readme.md
│ └── src/
│ └── bin/
│ ├── adc.rs
│ ├── aon_timer.rs
│ ├── bootsel.rs
│ ├── cyw43-perf.rs
│ ├── dma_copy_async.rs
│ ├── ethernet_w5100s_perf.rs
│ ├── flash.rs
│ ├── float.rs
│ ├── gpio.rs
│ ├── gpio_async.rs
│ ├── gpio_multicore.rs
│ ├── i2c.rs
│ ├── multicore.rs
│ ├── overclock.rs
│ ├── pio_irq.rs
│ ├── pio_multi_load.rs
│ ├── pwm.rs
│ ├── rtc.rs
│ ├── spi.rs
│ ├── spi_async.rs
│ ├── spinlock_mutex_multicore.rs
│ ├── timer.rs
│ ├── uart.rs
│ ├── uart_buffered.rs
│ ├── uart_dma.rs
│ └── uart_upgrade.rs
├── stm32/
│ ├── .cargo/
│ │ └── config.toml
│ ├── Cargo.toml
│ ├── build.rs
│ ├── gen_test.py
│ └── src/
│ ├── bin/
│ │ ├── adc.rs
│ │ ├── afio.rs
│ │ ├── can.rs
│ │ ├── cordic.rs
│ │ ├── cryp.rs
│ │ ├── dac.rs
│ │ ├── dac_l1.rs
│ │ ├── eeprom.rs
│ │ ├── eth.rs
│ │ ├── fdcan.rs
│ │ ├── gpio.rs
│ │ ├── hash.rs
│ │ ├── hsem.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── sdmmc.rs
│ │ ├── spi.rs
│ │ ├── spi_dma.rs
│ │ ├── stop.rs
│ │ ├── timer.rs
│ │ ├── ucpd.rs
│ │ ├── usart.rs
│ │ ├── usart_dma.rs
│ │ ├── usart_rx_ringbuffered.rs
│ │ ├── wpan_ble.rs
│ │ └── wpan_mac.rs
│ ├── can_common.rs
│ └── common.rs
└── utils/
├── Cargo.toml
└── src/
└── bin/
└── saturate_serial.rs
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitattributes
================================================
* text=auto
*.adoc text
*.html text
*.in text
*.json text
*.md text
*.proto text
*.py text
*.rs text
*.service text
*.sh text
*.toml text
*.txt text
*.x text
*.yml text
.vscode/*.json linguist-language=JSON-with-Comments
# Configure changelog files to use union merge strategy
# This prevents merge conflicts by automatically combining changes from both branches
CHANGELOG.md merge=union
changelog.md merge=union
CHANGELOG.txt merge=union
changelog.txt merge=union
*.raw binary
*.bin binary
*.png binary
*.jpg binary
*.jpeg binary
*.gif binary
*.ico binary
*.mov binary
*.mp4 binary
*.mp3 binary
*.flv binary
*.fla binary
*.swf binary
*.gz binary
*.zip binary
*.7z binary
*.ttf binary
*.eot binary
*.woff binary
*.pyc binary
*.pdf binary
*.ez binary
*.bz2 binary
*.swp binary
================================================
FILE: .github/ci/book.sh
================================================
#!/bin/bash
## on push branch=main
## priority -100
## dedup dequeue
## cooldown 15m
set -euxo pipefail
make -C docs
export KUBECONFIG=/ci/secrets/kubeconfig.yml
POD=$(kubectl get po -l app=website -o jsonpath={.items[0].metadata.name})
mkdir -p build
mv docs/book build/book
tar -C build -cf book.tar book
kubectl exec $POD -- mkdir -p /usr/share/nginx/html
kubectl cp book.tar $POD:/usr/share/nginx/html/
kubectl exec $POD -- find /usr/share/nginx/html
kubectl exec $POD -- tar -C /usr/share/nginx/html -xvf /usr/share/nginx/html/book.tar
================================================
FILE: .github/ci/build-nightly.sh
================================================
#!/bin/bash
## on push branch~=gh-readonly-queue/main/.*
## on pull_request
set -euo pipefail
export RUSTUP_HOME=/ci/cache/rustup
export CARGO_HOME=/ci/cache/cargo
export CARGO_TARGET_DIR=/ci/cache/target
export PATH=$CARGO_HOME/bin:$PATH
mv rust-toolchain-nightly.toml rust-toolchain.toml
# needed for "dumb HTTP" transport support
# used when pointing stm32-metapac to a CI-built one.
export CARGO_NET_GIT_FETCH_WITH_CLI=true
# Restore lockfiles
if [ -f /ci/cache/lockfiles.tar ]; then
echo Restoring lockfiles...
tar xf /ci/cache/lockfiles.tar
fi
hashtime restore /ci/cache/filetime.json || true
hashtime save /ci/cache/filetime.json
cargo install --git https://github.com/embassy-rs/cargo-embassy-devtool --locked --rev 8f4cfa11324c582467c2aab161ef963ff7a2b884
./ci-nightly.sh
# Save lockfiles
echo Saving lockfiles...
find . -type f -name Cargo.lock -exec tar -cf /ci/cache/lockfiles.tar '{}' \+
================================================
FILE: .github/ci/build-xtensa.sh
================================================
#!/bin/bash
## on push branch~=gh-readonly-queue/main/.*
## on pull_request
set -euo pipefail
export RUSTUP_HOME=/ci/cache/rustup
export CARGO_HOME=/ci/cache/cargo
export CARGO_TARGET_DIR=/ci/cache/target
export PATH=$CARGO_HOME/bin:$PATH
# needed for "dumb HTTP" transport support
# used when pointing stm32-metapac to a CI-built one.
export CARGO_NET_GIT_FETCH_WITH_CLI=true
cargo install espup --locked
espup install --toolchain-version 1.92.0.0
# Restore lockfiles
if [ -f /ci/cache/lockfiles.tar ]; then
echo Restoring lockfiles...
tar xf /ci/cache/lockfiles.tar
fi
hashtime restore /ci/cache/filetime.json || true
hashtime save /ci/cache/filetime.json
cargo install --git https://github.com/embassy-rs/cargo-embassy-devtool --locked --rev 8f4cfa11324c582467c2aab161ef963ff7a2b884
./ci-xtensa.sh
# Save lockfiles
echo Saving lockfiles...
find . -type f -name Cargo.lock -exec tar -cf /ci/cache/lockfiles.tar '{}' \+
================================================
FILE: .github/ci/build.sh
================================================
#!/bin/bash
## on push branch~=gh-readonly-queue/main/.*
## on pull_request
set -euo pipefail
export RUSTUP_HOME=/ci/cache/rustup
export CARGO_HOME=/ci/cache/cargo
export CARGO_TARGET_DIR=/ci/cache/target
export PATH=$CARGO_HOME/bin:$PATH
if [ -f /ci/secrets/teleprobe-token.txt ]; then
echo Got teleprobe token!
export TELEPROBE_HOST=https://teleprobe.embassy.dev
export TELEPROBE_TOKEN=$(cat /ci/secrets/teleprobe-token.txt)
export TELEPROBE_CACHE=/ci/cache/teleprobe_cache.json
fi
# needed for "dumb HTTP" transport support
# used when pointing stm32-metapac to a CI-built one.
export CARGO_NET_GIT_FETCH_WITH_CLI=true
# Restore lockfiles
if [ -f /ci/cache/lockfiles.tar ]; then
echo Restoring lockfiles...
tar xf /ci/cache/lockfiles.tar
fi
hashtime restore /ci/cache/filetime.json || true
hashtime save /ci/cache/filetime.json
cargo install --git https://github.com/embassy-rs/cargo-embassy-devtool --locked --rev 8f4cfa11324c582467c2aab161ef963ff7a2b884
./ci.sh
# Save lockfiles
echo Saving lockfiles...
find . -type f -name Cargo.lock -exec tar -cf /ci/cache/lockfiles.tar '{}' \+
================================================
FILE: .github/ci/doc.sh
================================================
#!/bin/bash
## on push branch=main
## priority -100
## dedup dequeue
## cooldown 15m
set -euxo pipefail
export RUSTUP_HOME=/ci/cache/rustup
export CARGO_HOME=/ci/cache/cargo
export CARGO_TARGET_DIR=/ci/cache/target
export PATH=$CARGO_HOME/bin:$PATH
mv rust-toolchain-nightly.toml rust-toolchain.toml
cargo install --git https://github.com/embassy-rs/cargo-embassy-devtool --locked --rev 8f4cfa11324c582467c2aab161ef963ff7a2b884
cargo install --git https://github.com/embassy-rs/docserver --locked --rev 09805a79beef037d283192146e2b546cb1c0e931
cargo embassy-devtool doc -o webroot
export KUBECONFIG=/ci/secrets/kubeconfig.yml
POD=$(kubectl get po -l app=docserver -o jsonpath={.items[0].metadata.name})
kubectl cp webroot/crates $POD:/data
kubectl cp webroot/static $POD:/data
================================================
FILE: .github/ci/janitor.sh
================================================
#!/bin/bash
## on push branch~=gh-readonly-queue/main/.*
## on pull_request
set -euo pipefail
export RUSTUP_HOME=/ci/cache/rustup
export CARGO_HOME=/ci/cache/cargo
export CARGO_TARGET_DIR=/ci/cache/target
export PATH=$CARGO_HOME/bin:$PATH
cargo install --git https://github.com/embassy-rs/cargo-embassy-devtool --locked --rev 8f4cfa11324c582467c2aab161ef963ff7a2b884
cargo embassy-devtool check-crlf
cargo embassy-devtool check-manifest
================================================
FILE: .github/ci/rustfmt.sh
================================================
#!/bin/bash
## on push branch~=gh-readonly-queue/main/.*
## on pull_request
set -euo pipefail
export RUSTUP_HOME=/ci/cache/rustup
export CARGO_HOME=/ci/cache/cargo
export CARGO_TARGET_DIR=/ci/cache/target
mv rust-toolchain-nightly.toml rust-toolchain.toml
find . -name '*.rs' -not -path '*target*' | xargs rustfmt --check --skip-children --unstable-features --edition 2024
================================================
FILE: .github/ci/test-nightly.sh
================================================
#!/bin/bash
## on push branch~=gh-readonly-queue/main/.*
## on pull_request
set -euo pipefail
export RUSTUP_HOME=/ci/cache/rustup
export CARGO_HOME=/ci/cache/cargo
export CARGO_TARGET_DIR=/ci/cache/target
mv rust-toolchain-nightly.toml rust-toolchain.toml
cargo test --manifest-path ./embassy-executor/Cargo.toml
cargo test --manifest-path ./embassy-executor/Cargo.toml --features nightly
MIRIFLAGS=-Zmiri-ignore-leaks cargo miri test --manifest-path ./embassy-executor/Cargo.toml
MIRIFLAGS=-Zmiri-ignore-leaks cargo miri test --manifest-path ./embassy-executor/Cargo.toml --features nightly
MIRIFLAGS=-Zmiri-ignore-leaks cargo miri test --manifest-path ./embassy-sync/Cargo.toml
================================================
FILE: .github/ci/test.sh
================================================
#!/bin/bash
## on push branch~=gh-readonly-queue/main/.*
## on pull_request
set -euo pipefail
export RUSTUP_HOME=/ci/cache/rustup
export CARGO_HOME=/ci/cache/cargo
export CARGO_TARGET_DIR=/ci/cache/target
# needed for "dumb HTTP" transport support
# used when pointing stm32-metapac to a CI-built one.
export CARGO_NET_GIT_FETCH_WITH_CLI=true
cargo test --manifest-path ./embassy-executor/Cargo.toml --features metadata-name
cargo test --manifest-path ./embassy-futures/Cargo.toml
cargo test --manifest-path ./embassy-sync/Cargo.toml
cargo test --manifest-path ./embassy-embedded-hal/Cargo.toml
cargo test --manifest-path ./embassy-hal-internal/Cargo.toml
cargo test --manifest-path ./embassy-time/Cargo.toml --features mock-driver,embassy-time-queue-utils/generic-queue-8
cargo test --manifest-path ./embassy-time-driver/Cargo.toml
cargo test --manifest-path ./embassy-boot/Cargo.toml
cargo test --manifest-path ./embassy-boot/Cargo.toml --features ed25519-dalek
cargo test --manifest-path ./embassy-boot/Cargo.toml --features ed25519-salty
cargo test --manifest-path ./embassy-nrf/Cargo.toml --no-default-features --features nrf52840,time-driver-rtc1,gpiote
cargo test --manifest-path ./embassy-rp/Cargo.toml --no-default-features --features time-driver,rp2040,_test
cargo test --manifest-path ./embassy-rp/Cargo.toml --no-default-features --features time-driver,rp235xa,_test
cargo test --manifest-path ./embassy-stm32/Cargo.toml --no-default-features --features stm32f429vg,time-driver-any,exti,single-bank
cargo test --manifest-path ./embassy-stm32/Cargo.toml --no-default-features --features stm32f429vg,time-driver-any,exti,dual-bank
cargo test --manifest-path ./embassy-stm32/Cargo.toml --no-default-features --features stm32f732ze,time-driver-any,exti
cargo test --manifest-path ./embassy-stm32/Cargo.toml --no-default-features --features stm32f769ni,time-driver-any,exti,single-bank
cargo test --manifest-path ./embassy-stm32/Cargo.toml --no-default-features --features stm32f769ni,time-driver-any,exti,dual-bank
cargo test --manifest-path ./embassy-net-adin1110/Cargo.toml
cargo test --manifest-path ./embassy-usb-dfu/Cargo.toml --features dfu
================================================
FILE: .github/workflows/matrix-bot-issues.yml
================================================
name: Matrix bot for issues
on:
issues:
types: [opened]
jobs:
notify:
if: github.repository == 'embassy-rs/embassy'
runs-on: ubuntu-latest
continue-on-error: true
steps:
- name: send message
uses: actions/github-script@v8
with:
script: |
const action = context.payload.action;
const title = context.payload.issue.title;
const issueBody = context.payload.issue.body;
const url = context.payload.issue.html_url;
// Determine message prefix
let prefix;
let roomId;
if (action === 'opened' && (title + ' ' + issueBody).toLowerCase().includes('esp32')) {
// Nag danielb
prefix = 'New Issue';
roomId = '!oENPKPHeKwiPfIVHER:matrix.org';
} else {
return; // Unknown action, skip
}
// HTML escape the title
const titleEscaped = title
.replace(/&/g, '&')
.replace(/</g, '<')
.replace(/>/g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''');
const body = `${prefix}: ${title} - ${url}`;
const formattedBody = `${prefix}: <a href="${url}">${titleEscaped}</a>`;
const accessToken = process.env.MATRIX_ACCESS_TOKEN;
const response = await fetch(
`https://matrix.org/_matrix/client/r0/rooms/${roomId}/send/m.room.message`,
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${accessToken}`
},
body: JSON.stringify({
msgtype: 'm.text',
format: 'org.matrix.custom.html',
body: body,
formatted_body: formattedBody
})
}
);
if (!response.ok) {
throw new Error(`Matrix API request failed: ${response.status} ${response.statusText}`);
}
env:
MATRIX_ACCESS_TOKEN: ${{ secrets.MATRIX_ACCESS_TOKEN }}
================================================
FILE: .github/workflows/matrix-bot.yml
================================================
name: Matrix bot
on:
pull_request_target:
types: [opened, closed]
jobs:
notify:
if: github.repository == 'embassy-rs/embassy'
runs-on: ubuntu-latest
continue-on-error: true
steps:
- name: send message
uses: actions/github-script@v8
with:
script: |
const action = context.payload.action;
const merged = context.payload.pull_request.merged;
const title = context.payload.pull_request.title;
const url = context.payload.pull_request.html_url;
// Determine message prefix
let prefix;
if (action === 'opened') {
prefix = 'New PR';
} else if (action === 'closed' && merged) {
prefix = 'PR merged';
} else if (action === 'closed' && !merged) {
prefix = 'PR closed without merging';
} else {
return; // Unknown action, skip
}
// HTML escape the title
const titleEscaped = title
.replace(/&/g, '&')
.replace(/</g, '<')
.replace(/>/g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''');
const body = `${prefix}: ${title} - ${url}`;
const formattedBody = `${prefix}: <a href="${url}">${titleEscaped}</a>`;
const roomId = '!YoLPkieCYHGzdjUhOK:matrix.org';
const accessToken = process.env.MATRIX_ACCESS_TOKEN;
const response = await fetch(
`https://matrix.org/_matrix/client/r0/rooms/${roomId}/send/m.room.message`,
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${accessToken}`
},
body: JSON.stringify({
msgtype: 'm.text',
format: 'org.matrix.custom.html',
body: body,
formatted_body: formattedBody
})
}
);
if (!response.ok) {
throw new Error(`Matrix API request failed: ${response.status} ${response.statusText}`);
}
env:
MATRIX_ACCESS_TOKEN: ${{ secrets.MATRIX_ACCESS_TOKEN }}
================================================
FILE: .gitignore
================================================
target
target_ci
target_ci_stable
Cargo.lock
third_party
webroot
/Cargo.toml
out/
# editor artifacts
.zed
.neoconf.json
*.vim
**/.idea
**/.nvim.lua
**/.cargo
!**/tests/**/.cargo
!**/examples/**/.cargo
================================================
FILE: .helix/languages.toml
================================================
[language-server.rust-analyzer.config.cargo]
allTargets = false
noDefaultFeatures = true
target = "thumbv8m.main-none-eabihf"
features = ["stm32n657x0", "time-driver-any", "unstable-pac", "exti"]
[language-server.rust-analyzer.config.check]
allTargets = false
noDefaultFeatures = true
target = "thumbv8m.main-none-eabihf"
features = ["stm32n657x0", "time-driver-any", "unstable-pac", "exti"]
================================================
FILE: .vscode/.gitignore
================================================
*.cortex-debug.*.json
launch.json
tasks.json
*.cfg
================================================
FILE: .vscode/extensions.json
================================================
{
// See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.
// Extension identifier format: ${publisher}.${name}. Example: vscode.csharp
// List of extensions which should be recommended for users of this workspace.
"recommendations": [
"rust-lang.rust-analyzer",
"tamasfe.even-better-toml",
],
// List of extensions recommended by VS Code that should not be recommended for users of this workspace.
"unwantedRecommendations": []
}
================================================
FILE: .vscode/settings.json
================================================
{
"[toml]": {
"editor.formatOnSave": false
},
"[markdown]": {
"editor.formatOnSave": false
},
"rust-analyzer.rustfmt.extraArgs": [
"+nightly"
],
"rust-analyzer.check.allTargets": false,
"rust-analyzer.check.noDefaultFeatures": true,
"rust-analyzer.cargo.noDefaultFeatures": true,
"rust-analyzer.showUnlinkedFileNotification": false,
// Uncomment the target of your chip.
//"rust-analyzer.cargo.target": "thumbv6m-none-eabi",
//"rust-analyzer.cargo.target": "thumbv7m-none-eabi",
"rust-analyzer.cargo.target": "thumbv7em-none-eabi",
//"rust-analyzer.cargo.target": "thumbv7em-none-eabihf",
//"rust-analyzer.cargo.target": "thumbv8m.main-none-eabihf",
"rust-analyzer.cargo.features": [
// Comment out these features when working on the examples. Most example crates do not have any cargo features.
"stm32f107rb",
"time-driver-any",
"unstable-pac",
"exti",
"rt",
],
"rust-analyzer.linkedProjects": [
"embassy-stm32/Cargo.toml",
// To work on the examples, comment the line above and all of the cargo.features lines,
// then uncomment ONE line below to select the chip you want to work on.
// This makes rust-analyzer work on the example crate and all its dependencies.
// "examples/mspm0c1104/Cargo.toml",
// "examples/mspm0g3507/Cargo.toml",
// "examples/mspm0g3519/Cargo.toml",
// "examples/mspm0g5187/Cargo.toml",
// "examples/mspm0l1306/Cargo.toml",
// "examples/mspm0l2228/Cargo.toml",
// "examples/nrf52840-rtic/Cargo.toml",
// "examples/nrf5340/Cargo.toml",
// "examples/nrf-rtos-trace/Cargo.toml",
// "examples/mimxrt1011/Cargo.toml",
// "examples/mimxrt1062-evk/Cargo.toml",
// "examples/rp/Cargo.toml",
// "examples/std/Cargo.toml",
// "examples/stm32c0/Cargo.toml",
// "examples/stm32f0/Cargo.toml",
// "examples/stm32f1/Cargo.toml",
// "examples/stm32f2/Cargo.toml",
// "examples/stm32f3/Cargo.toml",
// "examples/stm32f334/Cargo.toml",
// "examples/stm32f4/Cargo.toml",
// "examples/stm32f7/Cargo.toml",
// "examples/stm32g0/Cargo.toml",
// "examples/stm32g4/Cargo.toml",
// "examples/stm32h5/Cargo.toml",
// "examples/stm32h7/Cargo.toml",
// "examples/stm32l0/Cargo.toml",
// "examples/stm32l1/Cargo.toml",
// "examples/stm32l4/Cargo.toml",
// "examples/stm32l5/Cargo.toml",
// "examples/stm32u5/Cargo.toml",
// "examples/stm32wb/Cargo.toml",
// "examples/stm32wl/Cargo.toml",
// "examples/wasm/Cargo.toml",
],
}
================================================
FILE: LICENSE-APACHE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright (c) Embassy project contributors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: LICENSE-CC-BY-SA
================================================
Attribution-ShareAlike 4.0 International
=======================================================================
Creative Commons Corporation ("Creative Commons") is not a law firm and
does not provide legal services or legal advice. Distribution of
Creative Commons public licenses does not create a lawyer-client or
other relationship. Creative Commons makes its licenses and related
information available on an "as-is" basis. Creative Commons gives no
warranties regarding its licenses, any material licensed under their
terms and conditions, or any related information. Creative Commons
disclaims all liability for damages resulting from their use to the
fullest extent possible.
Using Creative Commons Public Licenses
Creative Commons public licenses provide a standard set of terms and
conditions that creators and other rights holders may use to share
original works of authorship and other material subject to copyright
and certain other rights specified in the public license below. The
following considerations are for informational purposes only, are not
exhaustive, and do not form part of our licenses.
Considerations for licensors: Our public licenses are
intended for use by those authorized to give the public
permission to use material in ways otherwise restricted by
copyright and certain other rights. Our licenses are
irrevocable. Licensors should read and understand the terms
and conditions of the license they choose before applying it.
Licensors should also secure all rights necessary before
applying our licenses so that the public can reuse the
material as expected. Licensors should clearly mark any
material not subject to the license. This includes other CC-
licensed material, or material used under an exception or
limitation to copyright. More considerations for licensors:
wiki.creativecommons.org/Considerations_for_licensors
Considerations for the public: By using one of our public
licenses, a licensor grants the public permission to use the
licensed material under specified terms and conditions. If
the licensor's permission is not necessary for any reason--for
example, because of any applicable exception or limitation to
copyright--then that use is not regulated by the license. Our
licenses grant only permissions under copyright and certain
other rights that a licensor has authority to grant. Use of
the licensed material may still be restricted for other
reasons, including because others have copyright or other
rights in the material. A licensor may make special requests,
such as asking that all changes be marked or described.
Although not required by our licenses, you are encouraged to
respect those requests where reasonable. More considerations
for the public:
wiki.creativecommons.org/Considerations_for_licensees
=======================================================================
Creative Commons Attribution-ShareAlike 4.0 International Public
License
By exercising the Licensed Rights (defined below), You accept and agree
to be bound by the terms and conditions of this Creative Commons
Attribution-ShareAlike 4.0 International Public License ("Public
License"). To the extent this Public License may be interpreted as a
contract, You are granted the Licensed Rights in consideration of Your
acceptance of these terms and conditions, and the Licensor grants You
such rights in consideration of benefits the Licensor receives from
making the Licensed Material available under these terms and
conditions.
Section 1 -- Definitions.
a. Adapted Material means material subject to Copyright and Similar
Rights that is derived from or based upon the Licensed Material
and in which the Licensed Material is translated, altered,
arranged, transformed, or otherwise modified in a manner requiring
permission under the Copyright and Similar Rights held by the
Licensor. For purposes of this Public License, where the Licensed
Material is a musical work, performance, or sound recording,
Adapted Material is always produced where the Licensed Material is
synched in timed relation with a moving image.
b. Adapter's License means the license You apply to Your Copyright
and Similar Rights in Your contributions to Adapted Material in
accordance with the terms and conditions of this Public License.
c. BY-SA Compatible License means a license listed at
creativecommons.org/compatiblelicenses, approved by Creative
Commons as essentially the equivalent of this Public License.
d. Copyright and Similar Rights means copyright and/or similar rights
closely related to copyright including, without limitation,
performance, broadcast, sound recording, and Sui Generis Database
Rights, without regard to how the rights are labeled or
categorized. For purposes of this Public License, the rights
specified in Section 2(b)(1)-(2) are not Copyright and Similar
Rights.
e. Effective Technological Measures means those measures that, in the
absence of proper authority, may not be circumvented under laws
fulfilling obligations under Article 11 of the WIPO Copyright
Treaty adopted on December 20, 1996, and/or similar international
agreements.
f. Exceptions and Limitations means fair use, fair dealing, and/or
any other exception or limitation to Copyright and Similar Rights
that applies to Your use of the Licensed Material.
g. License Elements means the license attributes listed in the name
of a Creative Commons Public License. The License Elements of this
Public License are Attribution and ShareAlike.
h. Licensed Material means the artistic or literary work, database,
or other material to which the Licensor applied this Public
License.
i. Licensed Rights means the rights granted to You subject to the
terms and conditions of this Public License, which are limited to
all Copyright and Similar Rights that apply to Your use of the
Licensed Material and that the Licensor has authority to license.
j. Licensor means the individual(s) or entity(ies) granting rights
under this Public License.
k. Share means to provide material to the public by any means or
process that requires permission under the Licensed Rights, such
as reproduction, public display, public performance, distribution,
dissemination, communication, or importation, and to make material
available to the public including in ways that members of the
public may access the material from a place and at a time
individually chosen by them.
l. Sui Generis Database Rights means rights other than copyright
resulting from Directive 96/9/EC of the European Parliament and of
the Council of 11 March 1996 on the legal protection of databases,
as amended and/or succeeded, as well as other essentially
equivalent rights anywhere in the world.
m. You means the individual or entity exercising the Licensed Rights
under this Public License. Your has a corresponding meaning.
Section 2 -- Scope.
a. License grant.
1. Subject to the terms and conditions of this Public License,
the Licensor hereby grants You a worldwide, royalty-free,
non-sublicensable, non-exclusive, irrevocable license to
exercise the Licensed Rights in the Licensed Material to:
a. reproduce and Share the Licensed Material, in whole or
in part; and
b. produce, reproduce, and Share Adapted Material.
2. Exceptions and Limitations. For the avoidance of doubt, where
Exceptions and Limitations apply to Your use, this Public
License does not apply, and You do not need to comply with
its terms and conditions.
3. Term. The term of this Public License is specified in Section
6(a).
4. Media and formats; technical modifications allowed. The
Licensor authorizes You to exercise the Licensed Rights in
all media and formats whether now known or hereafter created,
and to make technical modifications necessary to do so. The
Licensor waives and/or agrees not to assert any right or
authority to forbid You from making technical modifications
necessary to exercise the Licensed Rights, including
technical modifications necessary to circumvent Effective
Technological Measures. For purposes of this Public License,
simply making modifications authorized by this Section 2(a)
(4) never produces Adapted Material.
5. Downstream recipients.
a. Offer from the Licensor -- Licensed Material. Every
recipient of the Licensed Material automatically
receives an offer from the Licensor to exercise the
Licensed Rights under the terms and conditions of this
Public License.
b. Additional offer from the Licensor -- Adapted Material.
Every recipient of Adapted Material from You
automatically receives an offer from the Licensor to
exercise the Licensed Rights in the Adapted Material
under the conditions of the Adapter's License You apply.
c. No downstream restrictions. You may not offer or impose
any additional or different terms or conditions on, or
apply any Effective Technological Measures to, the
Licensed Material if doing so restricts exercise of the
Licensed Rights by any recipient of the Licensed
Material.
6. No endorsement. Nothing in this Public License constitutes or
may be construed as permission to assert or imply that You
are, or that Your use of the Licensed Material is, connected
with, or sponsored, endorsed, or granted official status by,
the Licensor or others designated to receive attribution as
provided in Section 3(a)(1)(A)(i).
b. Other rights.
1. Moral rights, such as the right of integrity, are not
licensed under this Public License, nor are publicity,
privacy, and/or other similar personality rights; however, to
the extent possible, the Licensor waives and/or agrees not to
assert any such rights held by the Licensor to the limited
extent necessary to allow You to exercise the Licensed
Rights, but not otherwise.
2. Patent and trademark rights are not licensed under this
Public License.
3. To the extent possible, the Licensor waives any right to
collect royalties from You for the exercise of the Licensed
Rights, whether directly or through a collecting society
under any voluntary or waivable statutory or compulsory
licensing scheme. In all other cases the Licensor expressly
reserves any right to collect such royalties.
Section 3 -- License Conditions.
Your exercise of the Licensed Rights is expressly made subject to the
following conditions.
a. Attribution.
1. If You Share the Licensed Material (including in modified
form), You must:
a. retain the following if it is supplied by the Licensor
with the Licensed Material:
i. identification of the creator(s) of the Licensed
Material and any others designated to receive
attribution, in any reasonable manner requested by
the Licensor (including by pseudonym if
designated);
ii. a copyright notice;
iii. a notice that refers to this Public License;
iv. a notice that refers to the disclaimer of
warranties;
v. a URI or hyperlink to the Licensed Material to the
extent reasonably practicable;
b. indicate if You modified the Licensed Material and
retain an indication of any previous modifications; and
c. indicate the Licensed Material is licensed under this
Public License, and include the text of, or the URI or
hyperlink to, this Public License.
2. You may satisfy the conditions in Section 3(a)(1) in any
reasonable manner based on the medium, means, and context in
which You Share the Licensed Material. For example, it may be
reasonable to satisfy the conditions by providing a URI or
hyperlink to a resource that includes the required
information.
3. If requested by the Licensor, You must remove any of the
information required by Section 3(a)(1)(A) to the extent
reasonably practicable.
b. ShareAlike.
In addition to the conditions in Section 3(a), if You Share
Adapted Material You produce, the following conditions also apply.
1. The Adapter's License You apply must be a Creative Commons
license with the same License Elements, this version or
later, or a BY-SA Compatible License.
2. You must include the text of, or the URI or hyperlink to, the
Adapter's License You apply. You may satisfy this condition
in any reasonable manner based on the medium, means, and
context in which You Share Adapted Material.
3. You may not offer or impose any additional or different terms
or conditions on, or apply any Effective Technological
Measures to, Adapted Material that restrict exercise of the
rights granted under the Adapter's License You apply.
Section 4 -- Sui Generis Database Rights.
Where the Licensed Rights include Sui Generis Database Rights that
apply to Your use of the Licensed Material:
a. for the avoidance of doubt, Section 2(a)(1) grants You the right
to extract, reuse, reproduce, and Share all or a substantial
portion of the contents of the database;
b. if You include all or a substantial portion of the database
contents in a database in which You have Sui Generis Database
Rights, then the database in which You have Sui Generis Database
Rights (but not its individual contents) is Adapted Material,
including for purposes of Section 3(b); and
c. You must comply with the conditions in Section 3(a) if You Share
all or a substantial portion of the contents of the database.
For the avoidance of doubt, this Section 4 supplements and does not
replace Your obligations under this Public License where the Licensed
Rights include other Copyright and Similar Rights.
Section 5 -- Disclaimer of Warranties and Limitation of Liability.
a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
c. The disclaimer of warranties and limitation of liability provided
above shall be interpreted in a manner that, to the extent
possible, most closely approximates an absolute disclaimer and
waiver of all liability.
Section 6 -- Term and Termination.
a. This Public License applies for the term of the Copyright and
Similar Rights licensed here. However, if You fail to comply with
this Public License, then Your rights under this Public License
terminate automatically.
b. Where Your right to use the Licensed Material has terminated under
Section 6(a), it reinstates:
1. automatically as of the date the violation is cured, provided
it is cured within 30 days of Your discovery of the
violation; or
2. upon express reinstatement by the Licensor.
For the avoidance of doubt, this Section 6(b) does not affect any
right the Licensor may have to seek remedies for Your violations
of this Public License.
c. For the avoidance of doubt, the Licensor may also offer the
Licensed Material under separate terms or conditions or stop
distributing the Licensed Material at any time; however, doing so
will not terminate this Public License.
d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
License.
Section 7 -- Other Terms and Conditions.
a. The Licensor shall not be bound by any additional or different
terms or conditions communicated by You unless expressly agreed.
b. Any arrangements, understandings, or agreements regarding the
Licensed Material not stated herein are separate from and
independent of the terms and conditions of this Public License.
Section 8 -- Interpretation.
a. For the avoidance of doubt, this Public License does not, and
shall not be interpreted to, reduce, limit, restrict, or impose
conditions on any use of the Licensed Material that could lawfully
be made without permission under this Public License.
b. To the extent possible, if any provision of this Public License is
deemed unenforceable, it shall be automatically reformed to the
minimum extent necessary to make it enforceable. If the provision
cannot be reformed, it shall be severed from this Public License
without affecting the enforceability of the remaining terms and
conditions.
c. No term or condition of this Public License will be waived and no
failure to comply consented to unless expressly agreed to by the
Licensor.
d. Nothing in this Public License constitutes or may be interpreted
as a limitation upon, or waiver of, any privileges and immunities
that apply to the Licensor or You, including from the legal
processes of any jurisdiction or authority.
=======================================================================
Creative Commons is not a party to its public
licenses. Notwithstanding, Creative Commons may elect to apply one of
its public licenses to material it publishes and in those instances
will be considered the “Licensor.” The text of the Creative Commons
public licenses is dedicated to the public domain under the CC0 Public
Domain Dedication. Except for the limited purpose of indicating that
material is shared under a Creative Commons public license or as
otherwise permitted by the Creative Commons policies published at
creativecommons.org/policies, Creative Commons does not authorize the
use of the trademark "Creative Commons" or any other trademark or logo
of Creative Commons without its prior written consent including,
without limitation, in connection with any unauthorized modifications
to any of its public licenses or any other arrangements,
understandings, or agreements concerning use of licensed material. For
the avoidance of doubt, this paragraph does not form part of the
public licenses.
Creative Commons may be contacted at creativecommons.org.
================================================
FILE: LICENSE-MIT
================================================
Copyright (c) Embassy project contributors
Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without
limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice
shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
================================================
FILE: NOTICE.md
================================================
# Notices for Embassy
This content is produced and maintained by the Embassy project contributors.
## Copyright
All content is the property of the respective authors or their employers.
For more information regarding authorship of content, please consult the
listed source code repository logs.
## Declared Project Licenses
This program and the accompanying materials are made available under the terms
of the Apache Software License 2.0 which is available at
https://www.apache.org/licenses/LICENSE-2.0, or the MIT license which is
available at https://opensource.org/licenses/MIT
================================================
FILE: README.md
================================================
# Embassy
Embassy is the next-generation framework for embedded applications. Write safe, correct, and energy-efficient embedded code faster, using the Rust programming language, its async facilities, and the Embassy libraries.
## [Documentation](https://embassy.dev/book/index.html) - [API reference](https://docs.embassy.dev/) - [Website](https://embassy.dev/) - [Chat](https://matrix.to/#/#embassy-rs:matrix.org)
## Rust + async ❤️ embedded
The Rust programming language is blazingly fast and memory-efficient, with no runtime, garbage collector, or OS. It catches a wide variety of bugs at compile time, thanks to its full memory- and thread-safety, and expressive type system.
Rust's [async/await](https://rust-lang.github.io/async-book/) allows for unprecedentedly easy and efficient multitasking in embedded systems. Tasks get transformed at compile time into state machines that get run cooperatively. It requires no dynamic memory allocation and runs on a single stack, so no per-task stack size tuning is required. It obsoletes the need for a traditional RTOS with kernel context switching, and is [faster and smaller than one!](https://tweedegolf.nl/en/blog/65/async-rust-vs-rtos-showdown)
## Batteries included
- **Hardware Abstraction Layers**
- HALs implement safe, idiomatic Rust APIs to use the hardware capabilities, so raw register manipulation is not needed. The Embassy project maintains HALs for select hardware, but you can still use HALs from other projects with Embassy.
- [embassy-stm32](https://docs.embassy.dev/embassy-stm32/), for all STM32 microcontroller families.
- [embassy-nrf](https://docs.embassy.dev/embassy-nrf/), for the Nordic Semiconductor nRF52, nRF53, nRF54 and nRF91 series.
- [embassy-rp](https://docs.embassy.dev/embassy-rp/), for the Raspberry Pi RP2040 and RP23xx microcontrollers.
- [embassy-mspm0](https://docs.embassy.dev/embassy-mspm0/), for the Texas Instruments MSPM0 microcontrollers.
- [embassy-mcxa](https://docs.embassy.dev/embassy-mcxa/), for NXP's MCX-A series of microcontrollers.
- [esp-rs](https://github.com/esp-rs), for the Espressif Systems ESP32 series of chips.
- Embassy HAL support for Espressif chips, as well as Async Wi-Fi, Bluetooth, and ESP-NOW, is being developed in the [esp-rs/esp-hal](https://github.com/esp-rs/esp-hal) repository.
- [ch32-hal](https://github.com/ch32-rs/ch32-hal), for the WCH 32-bit RISC-V(CH32V) series of chips.
- [mpfs-hal](https://github.com/AlexCharlton/mpfs-hal), for the Microchip PolarFire SoC.
- [py32-hal](https://github.com/py32-rs/py32-hal), for the Puya Semiconductor PY32 series of microcontrollers.
- **Time that Just Works** -
No more messing with hardware timers. [embassy_time](https://docs.embassy.dev/embassy-time) provides Instant, Duration, and Timer types that are globally available and never overflow.
- **Real-time ready** -
Tasks on the same async executor run cooperatively, but you can create multiple executors with different priorities so that higher priority tasks preempt lower priority ones. See the [example](https://github.com/embassy-rs/embassy/blob/main/examples/nrf52840/src/bin/multiprio.rs).
- **Low-power ready** -
Easily build devices with years of battery life. The async executor automatically puts the core to sleep when there's no work to do. Tasks are woken by interrupts, there is no busy-loop polling while waiting.
- **Networking** -
The [embassy-net](https://docs.embassy.dev/embassy-net/) network stack implements extensive networking functionality, including Ethernet, IP, TCP, UDP, ICMP, and DHCP. Async drastically simplifies managing timeouts and serving multiple connections concurrently.
- **Bluetooth**
- The [trouble](https://github.com/embassy-rs/trouble) crate provides a Bluetooth Low Energy 4.x and 5.x Host that runs on any microcontroller implementing the [bt-hci](https://github.com/embassy-rs/bt-hci) traits (currently
`nRF52`, `nrf54`, `rp2040`, `rp23xx` and `esp32` and `serial` controllers are supported).
- The [nrf-softdevice](https://github.com/embassy-rs/nrf-softdevice) crate provides Bluetooth Low Energy 4.x and 5.x support for nRF52 microcontrollers.
- The [embassy-stm32-wpan](https://github.com/embassy-rs/embassy/tree/main/embassy-stm32-wpan) crate provides Bluetooth Low Energy 5.x support for stm32wb microcontrollers.
- **LoRa** -
The [lora-rs](https://github.com/lora-rs/lora-rs) project provides an async LoRa and LoRaWAN stack that works well on Embassy.
- **USB** -
[embassy-usb](https://docs.embassy.dev/embassy-usb/) implements a device-side USB stack. Implementations for common classes such as USB serial (CDC ACM) and USB HID are available, and a rich builder API allows building your own.
- **Bootloader and DFU** -
[embassy-boot](https://github.com/embassy-rs/embassy/tree/main/embassy-boot) is a lightweight bootloader supporting firmware application upgrades in a power-fail-safe way, with trial boots and rollbacks.
## Sneak peek
```rust,ignore
use defmt::info;
use embassy_executor::Spawner;
use embassy_time::{Duration, Timer};
use embassy_nrf::gpio::{AnyPin, Input, Level, Output, OutputDrive, Pin, Pull};
use embassy_nrf::{Peri, Peripherals};
// Declare async tasks
#[embassy_executor::task]
async fn blink(pin: Peri<'static, AnyPin>) {
let mut led = Output::new(pin, Level::Low, OutputDrive::Standard);
loop {
// Timekeeping is globally available, no need to mess with hardware timers.
led.set_high();
Timer::after_millis(150).await;
led.set_low();
Timer::after_millis(150).await;
}
}
// Main is itself an async task as well.
#[embassy_executor::main]
async fn main(spawner: Spawner) {
let p = embassy_nrf::init(Default::default());
// Spawned tasks run in the background, concurrently.
spawner.spawn(blink(p.P0_13.into()).unwrap());
let mut button = Input::new(p.P0_11, Pull::Up);
loop {
// Asynchronously wait for GPIO events, allowing other tasks
// to run, or the core to sleep.
button.wait_for_low().await;
info!("Button pressed!");
button.wait_for_high().await;
info!("Button released!");
}
}
```
## Examples
Examples are found in the
`examples/` folder separated by the chip manufacturer they are designed to run on. For example:
* `examples/nrf52840` run on the
`nrf52840-dk` board (PCA10056) but should be easily adaptable to other nRF52 chips and boards.
* `examples/nrf5340` run on the `nrf5340-dk` board (PCA10095).
* `examples/stm32xx` for the various STM32 families.
* `examples/rp` are for the RP2040 and RP235x chips.
* `examples/mcxa` run on the `FRDM-MCXA266` board.
* `examples/std` are designed to run locally on your PC.
### Running examples
- Install `probe-rs` following the instructions at <https://probe.rs>.
- Change directory to the sample's base directory. For example:
```bash
cd examples/nrf52840
```
- Ensure `Cargo.toml` sets the right feature for the name of the chip you are programming.
If this name is incorrect, the example may fail to run or immediately crash
after being programmed.
- Ensure `.cargo/config.toml` contains the name of the chip you are programming.
- Run the example
For example:
```bash
cargo run --release --bin blinky
```
For more help getting started, see [Getting Started][1] and [Running the Examples][2].
## Developing Embassy with Rust Analyzer-based editors
The [Rust Analyzer](https://rust-analyzer.github.io/) is used by [Visual Studio Code](https://code.visualstudio.com/)
and others. Given the multiple targets that Embassy serves, there is no Cargo workspace file. Instead, the Rust Analyzer
must be told of the target project to work with. In the case of Visual Studio Code,
please refer to the `.vscode/settings.json` file's `rust-analyzer.linkedProjects`setting.
## Minimum supported Rust version (MSRV)
Embassy is guaranteed to compile on stable Rust 1.75 and up. It *might*
compile with older versions, but that may change in any new patch release.
## Why the name?
EMBedded ASYnc! :)
## License
Embassy is licensed under either of
- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or
<http://www.apache.org/licenses/LICENSE-2.0>)
- MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)
at your option.
## Contribution
Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.
[1]: https://embassy-rs.github.io/embassy-book/embassy/dev/getting_started.html
[2]: https://github.com/embassy-rs/embassy/wiki/Running-the-Examples
================================================
FILE: RELEASE.md
================================================
# RELEASE.md
This document outlines the process for releasing Embassy crates using `cargo-release` and the `release/bump-dependency.sh` script.
When releasing a crate, keep in mind that you may need to recursively release dependencies as well.
## Prerequisites
- Install [`cargo-release`](https://github.com/crate-ci/cargo-release):
```sh
cargo binstall cargo-release
## Crate release
Check if there are changes to the public API since the last release. If there is a breaking change, follow
the process for creating a minor release. Otherewise, follow the process for creating a new patch release.
Keep in mind that some crates may need the --features and --target flags passed to cargo release. For more information on that,
look at the `Cargo.toml` files.
### Patch release (no breaking public API changes)
```
cd embassy-nrf/
cargo release patch --features time,defmt,unstable-pac,gpiote,time-driver-rtc1,nrf52840 --target thumbv7em-none-eabi
# If dry-run is OK (no missing dependencies on crates.io)
cargo release patch --execute --features time,defmt,unstable-pac,gpiote,time-driver-rtc1,nrf52840 --target thumbv7em-none-eabi
```
### Minor release
```
# Bump versions in crate files
./release/bump-dependency.sh embassy-nrf 0.4.0
# Commit version bump
git commit -am 'chore: update to `embassy-nrf` v0.4.0'
# Release crate
cd embassy-nrf/
cargo release minor --features time,defmt,unstable-pac,gpiote,time-driver-rtc1,nrf52840 --target thumbv7em-none-eabi
# If dry-run is OK (no missing dependencies on crates.io)
cargo release minor --execute --features time,defmt,unstable-pac,gpiote,time-driver-rtc1,nrf52840 --target thumbv7em-none-eabi
```
## Push tags
Push the git tags that `cargo release` created earlier:
```
git push --tags
```
## Reference
* [PR introducing release automation](https://github.com/embassy-rs/embassy/pull/4289)
================================================
FILE: ci-nightly.sh
================================================
#!/bin/bash
set -eo pipefail
export RUSTFLAGS=-Dwarnings
export DEFMT_LOG=trace,embassy_hal_internal=debug,embassy_net_esp_hosted=debug,cyw43=info,cyw43_pio=info,smoltcp=info
if [[ -z "${CARGO_TARGET_DIR}" ]]; then
export CARGO_TARGET_DIR=target_ci
fi
cargo embassy-devtool build --group nightly
================================================
FILE: ci-xtensa.sh
================================================
#!/bin/bash
set -eo pipefail
export RUSTFLAGS=-Dwarnings
export DEFMT_LOG=trace,embassy_hal_internal=debug,embassy_net_esp_hosted=debug,cyw43=info,cyw43_pio=info,smoltcp=info
export RUSTUP_TOOLCHAIN=esp
if [[ -z "${CARGO_TARGET_DIR}" ]]; then
export CARGO_TARGET_DIR=target_ci
fi
cargo embassy-devtool build --group xtensa
================================================
FILE: ci.sh
================================================
#!/bin/bash
set -eo pipefail
if ! command -v cargo-batch &> /dev/null; then
echo "cargo-batch could not be found. Install it with the following command:"
echo ""
echo " cargo install --git https://github.com/embassy-rs/cargo-batch cargo --bin cargo-batch --locked"
echo ""
exit 1
fi
if ! command -v cargo-embassy-devtool &> /dev/null; then
echo "cargo-embassy-devtool could not be found. Install it with the following command:"
echo ""
echo " cargo install --git https://github.com/embassy-rs/cargo-embassy-devtool --locked"
echo ""
exit 1
fi
export RUSTFLAGS=-Dwarnings
export DEFMT_LOG=trace,embassy_hal_internal=debug,embassy_net_esp_hosted=debug,cyw43=info,cyw43_pio=info,smoltcp=info
if [[ -z "${CARGO_TARGET_DIR}" ]]; then
export CARGO_TARGET_DIR=target_ci
fi
cargo embassy-devtool build
# temporarily disabled, these boards are dead.
rm -rf out/tests/stm32f103c8
rm -rf out/tests/nrf52840-dk
rm -rf out/tests/nrf52833-dk
rm -rf out/tests/nrf5340-dk
# disabled because these boards are not on the shelf
rm -rf out/tests/mspm0g3507
rm out/tests/stm32wb55rg/wpan_mac
rm out/tests/stm32wb55rg/wpan_ble
# unstable, I think it's running out of RAM?
rm out/tests/stm32f207zg/eth
# temporarily disabled, flaky.
rm out/tests/stm32f207zg/usart_rx_ringbuffered
rm out/tests/stm32l152re/usart_rx_ringbuffered
# doesn't work, gives "noise error", no idea why. usart_dma does pass.
rm out/tests/stm32u5a5zj/usart
# probe-rs error: "multi-core ram flash start not implemented yet"
# As of 2025-02-17 these tests work when run from flash
rm out/tests/pimoroni-pico-plus-2/multicore
rm out/tests/pimoroni-pico-plus-2/gpio_multicore
rm out/tests/pimoroni-pico-plus-2/spinlock_mutex_multicore
# Doesn't work when run from ram on the 2350
rm out/tests/pimoroni-pico-plus-2/flash
# This test passes locally but fails on the HIL, no idea why
rm out/tests/pimoroni-pico-plus-2/i2c
# The pico2 plus doesn't have the adcs hooked up like the picoW does.
rm out/tests/pimoroni-pico-plus-2/adc
# temporarily disabled
rm out/tests/pimoroni-pico-plus-2/pwm
rm out/tests/frdm-mcx-a266/trng
# flaky
rm out/tests/rpi-pico/pwm
rm out/tests/rpi-pico/cyw43-perf
rm out/tests/rpi-pico/uart_buffered
rm out/tests/rpi-pico/spi_async
rm out/tests/stm32h563zi/usart_dma
# tests are implemented but the HIL test farm doesn't actually have these boards, yet
rm -rf out/tests/stm32c071rb
rm -rf out/tests/stm32f100rd
rm -rf out/tests/stm32f107vc
if [[ -z "${TELEPROBE_TOKEN-}" ]]; then
echo No teleprobe token found, skipping running HIL tests
exit
fi
teleprobe client run -r out/tests
================================================
FILE: cyw43/CHANGELOG.md
================================================
# Changelog
All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
<!-- next-header -->
## Unreleased - ReleaseDate
## 0.7.0 - 2026-03-10
- Reset WPA security before creating secure AP
- Add `get_rssi()` to `Controller`
- Implement link state monitoring
- Always unsubscribe to cyw43 events (fix event leak)
- Add SDIO support for STM32
- Allow specifying nvram, get LWB+ working
- Improve join handling with better error reporting
- Replace `num_enum` dependency with internal macro
- Bump bt-hci to 0.8.0.
- Update to embedded-io 0.7
- Update embassy-sync to 0.8.0
- Update embassy-net-driver-channel to 0.4.0
## 0.6.0 - 2025-11-27
- Updated documentation for Control::join() #4678
- Bump bt-hci to 0.6.0.
- Add error handling to HCI transport implementation.
- Reset WPA security on AP creation #4709
## 0.5.0 - 2025-08-28
- bump bt-hci to 0.4.0
## 0.4.1 - 2025-08-26 (yanked)
- bump bt-hci to 0.4.0
## 0.4.0 - 2025-07-15
- bump embassy-sync to 0.7.0
- bump bt-hci to 0.3.0
- make State::new const fn
## 0.3.0 - 2025-01-05
- Update `embassy-time` to 0.4.0
- Add Bluetooth support.
- Add WPA3 support.
- Expand wifi security configuration options.
## 0.2.0 - 2024-08-05
- Update to new versions of embassy-{time,sync}
- Add more fields to the BssInfo packet struct #2461
- Extend the Scan API #2282
- Reuse buf to reduce stack usage #2580
- Add MAC address getter to cyw43 controller #2818
- Add function to join WPA2 network with precomputed PSK. #2885
- Add function to close soft AP. #3042
- Fixing missing re-export #3211
## 0.1.0 - 2024-01-11
- First release
================================================
FILE: cyw43/Cargo.toml
================================================
[package]
name = "cyw43"
version = "0.7.0"
edition = "2024"
description = "Rust driver for the CYW43439 WiFi chip, used in the Raspberry Pi Pico W."
keywords = ["embedded", "cyw43", "embassy-net", "embedded-hal-async", "wifi"]
categories = ["embedded", "hardware-support", "no-std", "network-programming", "asynchronous"]
license = "MIT OR Apache-2.0"
repository = "https://github.com/embassy-rs/embassy"
documentation = "https://docs.embassy.dev/cyw43"
[features]
defmt = ["dep:defmt", "heapless/defmt", "embassy-time/defmt", "bt-hci?/defmt", "embedded-io-async?/defmt"]
log = ["dep:log", "dep:derive_more", "derive_more/display"]
bluetooth = ["dep:bt-hci", "dep:embedded-io-async"]
# Fetch console logs from the WiFi firmware and forward them to `log` or `defmt`.
firmware-logs = []
[dependencies]
embassy-time = { version = "0.5.1", path = "../embassy-time"}
embassy-sync = { version = "0.8.0", path = "../embassy-sync"}
embassy-futures = { version = "0.1.2", path = "../embassy-futures"}
embassy-net-driver-channel = { version = "0.4.0", path = "../embassy-net-driver-channel"}
defmt = { version = "1.0.1", optional = true }
log = { version = "0.4.17", optional = true }
derive_more = { version = "2.1.1", optional = true, default-features =false }
cortex-m = "0.7.6"
cortex-m-rt = "0.7.0"
futures = { version = "0.3.17", default-features = false, features = ["async-await", "cfg-target-has-atomic", "unstable"] }
embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
embedded-hal-async = { version = "1.0" }
heapless = "0.9"
aligned = "0.4.3"
# Bluetooth deps
embedded-io-async = { version = "0.7.0", optional = true }
bt-hci = { version = "0.8", optional = true }
[package.metadata.embassy]
build = [
{target = "thumbv6m-none-eabi", features = []},
{target = "thumbv6m-none-eabi", features = ["log"]},
{target = "thumbv6m-none-eabi", features = ["defmt"]},
{target = "thumbv6m-none-eabi", features = ["firmware-logs", "log"]},
{target = "thumbv6m-none-eabi", features = ["defmt", "firmware-logs"]},
{target = "thumbv6m-none-eabi", features = ["bluetooth", "firmware-logs", "log"]},
{target = "thumbv6m-none-eabi", features = ["bluetooth", "defmt", "firmware-logs"]},
]
[package.metadata.embassy_docs]
src_base = "https://github.com/embassy-rs/embassy/blob/cyw43-v$VERSION/cyw43/src/"
src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/cyw43/src/"
target = "thumbv6m-none-eabi"
features = ["defmt", "firmware-logs"]
[package.metadata.docs.rs]
features = ["defmt", "firmware-logs"]
================================================
FILE: cyw43/README.md
================================================
# cyw43
Rust driver for the CYW43439 wifi+bluetooth chip. Implementation based on [Infineon/wifi-host-driver](https://github.com/Infineon/wifi-host-driver).
Works on the following boards:
- Raspberry Pi Pico W (RP2040)
- Raspberry Pi Pico 2 W (RP2350A)
- Pimoroni Pico Plus 2 W (RP2350B)
- Any board with Raspberry Pi RM2 radio module.
- Any board with the CYW43439 chip, and possibly others if the protocol is similar enough.
## Features
Working:
- WiFi support
- Station mode (joining an AP).
- AP mode (creating an AP)
- Scanning
- Sending and receiving Ethernet frames.
- Using the default MAC address.
- [`embassy-net`](https://embassy.dev) integration.
- RP2040 PIO driver for the nonstandard half-duplex SPI used in the Pico W.
- Using IRQ for device events, no busy polling.
- GPIO support (for LED on the Pico W).
- Bluetooth support
- Bluetooth Classic + LE HCI commands.
- Concurrent operation with WiFi.
- Implements the [bt-hci](https://crates.io/crates/bt-hci) controller traits.
- Works with the [TrouBLE](https://github.com/embassy-rs/trouble) bluetooth LE stack. Check its repo for examples using `cyw43`.
## Running the WiFi examples
- Install `probe-rs` following the instructions at <https://probe.rs>.
- `cd examples/rp`
### Example 1: Scan the wifi stations
- `cargo run --release --bin wifi_scan`
### Example 2: Create an access point (IP and credentials in the code)
- `cargo run --release --bin wifi_ap_tcp_server`
### Example 3: Connect to an existing network and create a server
- `cargo run --release --bin wifi_tcp_server`
After a few seconds, you should see that DHCP picks up an IP address like this
```
11.944489 DEBUG Acquired IP configuration:
11.944517 DEBUG IP address: 192.168.0.250/24
11.944620 DEBUG Default gateway: 192.168.0.33
11.944722 DEBUG DNS server 0: 192.168.0.33
```
This example implements a TCP echo server on port 1234. You can try connecting to it with:
```
nc 192.168.0.250 1234
```
Send it some data, you should see it echoed back and printed in the firmware's logs.
================================================
FILE: cyw43/src/bluetooth.rs
================================================
use core::cell::RefCell;
use core::future::Future;
use core::mem::MaybeUninit;
use bt_hci::transport::WithIndicator;
use bt_hci::{ControllerToHostPacket, FromHciBytes, FromHciBytesError, HostToControllerPacket, PacketKind, WriteHci};
use embassy_futures::yield_now;
use embassy_sync::blocking_mutex::raw::NoopRawMutex;
use embassy_sync::zerocopy_channel;
use embassy_time::{Duration, Timer};
use embedded_io_async::ErrorKind;
use crate::consts::*;
use crate::runner::Bus;
pub use crate::spi::SpiBusCyw43;
use crate::util::round_up;
use crate::{CHIP, util};
pub(crate) struct BtState {
rx: [BtPacketBuf; 4],
tx: [BtPacketBuf; 4],
inner: MaybeUninit<BtStateInnre<'static>>,
}
impl BtState {
pub const fn new() -> Self {
Self {
rx: [const { BtPacketBuf::new() }; 4],
tx: [const { BtPacketBuf::new() }; 4],
inner: MaybeUninit::uninit(),
}
}
}
struct BtStateInnre<'d> {
rx: zerocopy_channel::Channel<'d, NoopRawMutex, BtPacketBuf>,
tx: zerocopy_channel::Channel<'d, NoopRawMutex, BtPacketBuf>,
}
/// Bluetooth driver.
pub struct BtDriver<'d> {
rx: RefCell<zerocopy_channel::Receiver<'d, NoopRawMutex, BtPacketBuf>>,
tx: RefCell<zerocopy_channel::Sender<'d, NoopRawMutex, BtPacketBuf>>,
}
pub(crate) struct BtRunner<'d> {
pub(crate) tx_chan: zerocopy_channel::Receiver<'d, NoopRawMutex, BtPacketBuf>,
rx_chan: zerocopy_channel::Sender<'d, NoopRawMutex, BtPacketBuf>,
// Bluetooth circular buffers
addr: u32,
h2b_write_pointer: u32,
b2h_read_pointer: u32,
}
const BT_HCI_MTU: usize = 1024;
/// Represents a packet of size MTU.
pub(crate) struct BtPacketBuf {
pub(crate) len: usize,
pub(crate) buf: [u8; BT_HCI_MTU],
}
impl BtPacketBuf {
/// Create a new packet buffer.
pub const fn new() -> Self {
Self {
len: 0,
buf: [0; BT_HCI_MTU],
}
}
}
pub(crate) fn new<'d>(state: &'d mut BtState) -> (BtRunner<'d>, BtDriver<'d>) {
// safety: this is a self-referential struct, however:
// - it can't move while the `'d` borrow is active.
// - when the borrow ends, the dangling references inside the MaybeUninit will never be used again.
let state_uninit: *mut MaybeUninit<BtStateInnre<'d>> =
(&mut state.inner as *mut MaybeUninit<BtStateInnre<'static>>).cast();
let state = unsafe { &mut *state_uninit }.write(BtStateInnre {
rx: zerocopy_channel::Channel::new(&mut state.rx[..]),
tx: zerocopy_channel::Channel::new(&mut state.tx[..]),
});
let (rx_sender, rx_receiver) = state.rx.split();
let (tx_sender, tx_receiver) = state.tx.split();
(
BtRunner {
tx_chan: tx_receiver,
rx_chan: rx_sender,
addr: 0,
h2b_write_pointer: 0,
b2h_read_pointer: 0,
},
BtDriver {
rx: RefCell::new(rx_receiver),
tx: RefCell::new(tx_sender),
},
)
}
pub(crate) struct CybtFwCb<'a> {
pub p_next_line_start: &'a [u8],
}
pub(crate) struct HexFileData<'a> {
pub addr_mode: i32,
pub hi_addr: u16,
pub dest_addr: u32,
pub p_ds: &'a mut [u8],
}
pub(crate) fn read_firmware_patch_line(p_btfw_cb: &mut CybtFwCb, hfd: &mut HexFileData) -> u32 {
let mut abs_base_addr32 = 0;
loop {
let num_bytes = p_btfw_cb.p_next_line_start[0];
p_btfw_cb.p_next_line_start = &p_btfw_cb.p_next_line_start[1..];
let addr = (p_btfw_cb.p_next_line_start[0] as u16) << 8 | p_btfw_cb.p_next_line_start[1] as u16;
p_btfw_cb.p_next_line_start = &p_btfw_cb.p_next_line_start[2..];
let line_type = p_btfw_cb.p_next_line_start[0];
p_btfw_cb.p_next_line_start = &p_btfw_cb.p_next_line_start[1..];
if num_bytes == 0 {
break;
}
hfd.p_ds[..num_bytes as usize].copy_from_slice(&p_btfw_cb.p_next_line_start[..num_bytes as usize]);
p_btfw_cb.p_next_line_start = &p_btfw_cb.p_next_line_start[num_bytes as usize..];
match line_type {
BTFW_HEX_LINE_TYPE_EXTENDED_ADDRESS => {
hfd.hi_addr = (hfd.p_ds[0] as u16) << 8 | hfd.p_ds[1] as u16;
hfd.addr_mode = BTFW_ADDR_MODE_EXTENDED;
}
BTFW_HEX_LINE_TYPE_EXTENDED_SEGMENT_ADDRESS => {
hfd.hi_addr = (hfd.p_ds[0] as u16) << 8 | hfd.p_ds[1] as u16;
hfd.addr_mode = BTFW_ADDR_MODE_SEGMENT;
}
BTFW_HEX_LINE_TYPE_ABSOLUTE_32BIT_ADDRESS => {
abs_base_addr32 = (hfd.p_ds[0] as u32) << 24
| (hfd.p_ds[1] as u32) << 16
| (hfd.p_ds[2] as u32) << 8
| hfd.p_ds[3] as u32;
hfd.addr_mode = BTFW_ADDR_MODE_LINEAR32;
}
BTFW_HEX_LINE_TYPE_DATA => {
hfd.dest_addr = addr as u32;
match hfd.addr_mode {
BTFW_ADDR_MODE_EXTENDED => hfd.dest_addr += (hfd.hi_addr as u32) << 16,
BTFW_ADDR_MODE_SEGMENT => hfd.dest_addr += (hfd.hi_addr as u32) << 4,
BTFW_ADDR_MODE_LINEAR32 => hfd.dest_addr += abs_base_addr32,
_ => {}
}
return num_bytes as u32;
}
_ => {}
}
}
0
}
impl<'a> BtRunner<'a> {
pub(crate) async fn init_bluetooth(&mut self, bus: &mut impl Bus, firmware: &[u8]) {
trace!("init_bluetooth");
bus.bp_write32(CHIP.bluetooth_base_address + BT2WLAN_PWRUP_ADDR, BT2WLAN_PWRUP_WAKE)
.await;
Timer::after(Duration::from_millis(2)).await;
self.upload_bluetooth_firmware(bus, firmware).await;
self.wait_bt_ready(bus).await;
self.init_bt_buffers(bus).await;
self.wait_bt_awake(bus).await;
self.bt_set_host_ready(bus).await;
self.bt_toggle_intr(bus).await;
}
pub(crate) async fn upload_bluetooth_firmware(&mut self, bus: &mut impl Bus, firmware: &[u8]) {
// read version
let version_length = firmware[0];
let _version = &firmware[1..=version_length as usize];
// skip version + 1 extra byte as per cybt_shared_bus_driver.c
let firmware = &firmware[version_length as usize + 2..];
// buffers
let mut data_buffer: [u8; 0x100] = [0; 0x100];
let mut aligned_data_buffer: [u8; 0x100] = [0; 0x100];
// structs
let mut btfw_cb = CybtFwCb {
p_next_line_start: firmware,
};
let mut hfd = HexFileData {
addr_mode: BTFW_ADDR_MODE_EXTENDED,
hi_addr: 0,
dest_addr: 0,
p_ds: &mut data_buffer,
};
loop {
let num_fw_bytes = read_firmware_patch_line(&mut btfw_cb, &mut hfd);
if num_fw_bytes == 0 {
break;
}
let fw_bytes = &hfd.p_ds[0..num_fw_bytes as usize];
let mut dest_start_addr = hfd.dest_addr + CHIP.bluetooth_base_address;
let mut aligned_data_buffer_index: usize = 0;
// pad start
if !util::is_aligned(dest_start_addr, 4) {
let num_pad_bytes = dest_start_addr % 4;
let padded_dest_start_addr = util::round_down(dest_start_addr, 4);
let memory_value = bus.bp_read32(padded_dest_start_addr).await;
let memory_value_bytes = memory_value.to_le_bytes();
// Copy the previous memory value's bytes to the start
for i in 0..num_pad_bytes as usize {
aligned_data_buffer[aligned_data_buffer_index] = memory_value_bytes[i];
aligned_data_buffer_index += 1;
}
// Copy the firmware bytes after the padding bytes
for i in 0..num_fw_bytes as usize {
aligned_data_buffer[aligned_data_buffer_index] = fw_bytes[i];
aligned_data_buffer_index += 1;
}
dest_start_addr = padded_dest_start_addr;
} else {
// Directly copy fw_bytes into aligned_data_buffer if no start padding is required
for i in 0..num_fw_bytes as usize {
aligned_data_buffer[aligned_data_buffer_index] = fw_bytes[i];
aligned_data_buffer_index += 1;
}
}
// pad end
let mut dest_end_addr = dest_start_addr + aligned_data_buffer_index as u32;
if !util::is_aligned(dest_end_addr, 4) {
let offset = dest_end_addr % 4;
let num_pad_bytes_end = 4 - offset;
let padded_dest_end_addr = util::round_down(dest_end_addr, 4);
let memory_value = bus.bp_read32(padded_dest_end_addr).await;
let memory_value_bytes = memory_value.to_le_bytes();
// Append the necessary memory bytes to pad the end of aligned_data_buffer
for i in offset..4 {
aligned_data_buffer[aligned_data_buffer_index] = memory_value_bytes[i as usize];
aligned_data_buffer_index += 1;
}
dest_end_addr += num_pad_bytes_end;
} else {
// pad end alignment not needed
}
let buffer_to_write = &aligned_data_buffer[0..aligned_data_buffer_index as usize];
assert!(dest_start_addr % 4 == 0);
assert!(dest_end_addr % 4 == 0);
assert!(aligned_data_buffer_index % 4 == 0);
bus.bp_write(dest_start_addr, buffer_to_write).await;
}
}
pub(crate) async fn wait_bt_ready(&mut self, bus: &mut impl Bus) {
trace!("wait_bt_ready");
let mut success = false;
for _ in 0..300 {
let val = bus.bp_read32(BT_CTRL_REG_ADDR).await;
trace!("BT_CTRL_REG_ADDR = {:08x}", val);
if val & BTSDIO_REG_FW_RDY_BITMASK != 0 {
success = true;
break;
}
Timer::after(Duration::from_millis(1)).await;
}
assert!(success == true);
}
pub(crate) async fn wait_bt_awake(&mut self, bus: &mut impl Bus) {
trace!("wait_bt_awake");
let mut success = false;
for _ in 0..300 {
let val = bus.bp_read32(BT_CTRL_REG_ADDR).await;
trace!("BT_CTRL_REG_ADDR = {:08x}", val);
if val & BTSDIO_REG_BT_AWAKE_BITMASK != 0 {
success = true;
break;
}
Timer::after(Duration::from_millis(1)).await;
}
assert!(success == true);
}
pub(crate) async fn bt_set_host_ready(&mut self, bus: &mut impl Bus) {
trace!("bt_set_host_ready");
let old_val = bus.bp_read32(HOST_CTRL_REG_ADDR).await;
// TODO: do we need to swap endianness on this read?
let new_val = old_val | BTSDIO_REG_SW_RDY_BITMASK;
bus.bp_write32(HOST_CTRL_REG_ADDR, new_val).await;
}
// TODO: use this
#[allow(dead_code)]
pub(crate) async fn bt_set_awake(&mut self, bus: &mut impl Bus, awake: bool) {
trace!("bt_set_awake");
let old_val = bus.bp_read32(HOST_CTRL_REG_ADDR).await;
// TODO: do we need to swap endianness on this read?
let new_val = if awake {
old_val | BTSDIO_REG_WAKE_BT_BITMASK
} else {
old_val & !BTSDIO_REG_WAKE_BT_BITMASK
};
bus.bp_write32(HOST_CTRL_REG_ADDR, new_val).await;
}
pub(crate) async fn bt_toggle_intr(&mut self, bus: &mut impl Bus) {
trace!("bt_toggle_intr");
let old_val = bus.bp_read32(HOST_CTRL_REG_ADDR).await;
// TODO: do we need to swap endianness on this read?
let new_val = old_val ^ BTSDIO_REG_DATA_VALID_BITMASK;
bus.bp_write32(HOST_CTRL_REG_ADDR, new_val).await;
}
// TODO: use this
#[allow(dead_code)]
pub(crate) async fn bt_set_intr(&mut self, bus: &mut impl Bus) {
trace!("bt_set_intr");
let old_val = bus.bp_read32(HOST_CTRL_REG_ADDR).await;
let new_val = old_val | BTSDIO_REG_DATA_VALID_BITMASK;
bus.bp_write32(HOST_CTRL_REG_ADDR, new_val).await;
}
pub(crate) async fn init_bt_buffers(&mut self, bus: &mut impl Bus) {
trace!("init_bt_buffers");
self.addr = bus.bp_read32(WLAN_RAM_BASE_REG_ADDR).await;
assert!(self.addr != 0);
trace!("wlan_ram_base_addr = {:08x}", self.addr);
bus.bp_write32(self.addr + BTSDIO_OFFSET_HOST2BT_IN, 0).await;
bus.bp_write32(self.addr + BTSDIO_OFFSET_HOST2BT_OUT, 0).await;
bus.bp_write32(self.addr + BTSDIO_OFFSET_BT2HOST_IN, 0).await;
bus.bp_write32(self.addr + BTSDIO_OFFSET_BT2HOST_OUT, 0).await;
}
async fn bt_bus_request(&mut self, bus: &mut impl Bus) {
// TODO: CYW43_THREAD_ENTER mutex?
self.bt_set_awake(bus, true).await;
self.wait_bt_awake(bus).await;
}
pub(crate) async fn hci_write(&mut self, bus: &mut impl Bus) {
self.bt_bus_request(bus).await;
// NOTE(unwrap): we only call this when we do have a packet in the queue.
let buf = self.tx_chan.try_receive().unwrap();
debug!("HCI tx: {:02x}", crate::fmt::Bytes(&buf.buf[..buf.len]));
let len = buf.len as u32 - 1; // len doesn't include hci type byte
let rounded_len = round_up(len, 4);
let total_len = 4 + rounded_len;
let read_pointer = bus.bp_read32(self.addr + BTSDIO_OFFSET_HOST2BT_OUT).await;
let available = read_pointer.wrapping_sub(self.h2b_write_pointer + 4) % BTSDIO_FWBUF_SIZE;
if available < total_len {
warn!(
"bluetooth tx queue full, retrying. len {} available {}",
total_len, available
);
yield_now().await;
return;
}
// Build header
let mut header = [0u8; 4];
header[0] = len as u8;
header[1] = (len >> 8) as u8;
header[2] = (len >> 16) as u8;
header[3] = buf.buf[0]; // HCI type byte
// Write header
let addr = self.addr + BTSDIO_OFFSET_HOST_WRITE_BUF + self.h2b_write_pointer;
bus.bp_write(addr, &header).await;
self.h2b_write_pointer = (self.h2b_write_pointer + 4) % BTSDIO_FWBUF_SIZE;
// Write payload.
let payload = &buf.buf[1..][..rounded_len as usize];
if self.h2b_write_pointer as usize + payload.len() > BTSDIO_FWBUF_SIZE as usize {
// wraparound
let n = BTSDIO_FWBUF_SIZE - self.h2b_write_pointer;
let addr = self.addr + BTSDIO_OFFSET_HOST_WRITE_BUF + self.h2b_write_pointer;
bus.bp_write(addr, &payload[..n as usize]).await;
let addr = self.addr + BTSDIO_OFFSET_HOST_WRITE_BUF;
bus.bp_write(addr, &payload[n as usize..]).await;
} else {
// no wraparound
let addr = self.addr + BTSDIO_OFFSET_HOST_WRITE_BUF + self.h2b_write_pointer;
bus.bp_write(addr, payload).await;
}
self.h2b_write_pointer = (self.h2b_write_pointer + payload.len() as u32) % BTSDIO_FWBUF_SIZE;
// Update pointer.
bus.bp_write32(self.addr + BTSDIO_OFFSET_HOST2BT_IN, self.h2b_write_pointer)
.await;
self.bt_toggle_intr(bus).await;
self.tx_chan.receive_done();
}
async fn bt_has_work(&mut self, bus: &mut impl Bus) -> bool {
let int_status = bus.bp_read32(CHIP.sdiod_core_base_address + SDIO_INT_STATUS).await;
if int_status & I_HMB_FC_CHANGE != 0 {
bus.bp_write32(
CHIP.sdiod_core_base_address + SDIO_INT_STATUS,
int_status & I_HMB_FC_CHANGE,
)
.await;
return true;
}
return false;
}
pub(crate) async fn handle_irq(&mut self, bus: &mut impl Bus) {
if self.bt_has_work(bus).await {
loop {
// Check if we have data.
let write_pointer = bus.bp_read32(self.addr + BTSDIO_OFFSET_BT2HOST_IN).await;
let available = write_pointer.wrapping_sub(self.b2h_read_pointer) % BTSDIO_FWBUF_SIZE;
if available == 0 {
break;
}
// read header
let mut header = [0u8; 4];
let addr = self.addr + BTSDIO_OFFSET_HOST_READ_BUF + self.b2h_read_pointer;
bus.bp_read(addr, &mut header).await;
// calc length
let len = header[0] as u32 | ((header[1]) as u32) << 8 | ((header[2]) as u32) << 16;
let rounded_len = round_up(len, 4);
if available < 4 + rounded_len {
warn!("ringbuf data not enough for a full packet?");
break;
}
self.b2h_read_pointer = (self.b2h_read_pointer + 4) % BTSDIO_FWBUF_SIZE;
// Obtain a buf from the channel.
let buf = self.rx_chan.send().await;
buf.buf[0] = header[3]; // hci packet type
let payload = &mut buf.buf[1..][..rounded_len as usize];
if self.b2h_read_pointer as usize + payload.len() > BTSDIO_FWBUF_SIZE as usize {
// wraparound
let n = BTSDIO_FWBUF_SIZE - self.b2h_read_pointer;
let addr = self.addr + BTSDIO_OFFSET_HOST_READ_BUF + self.b2h_read_pointer;
bus.bp_read(addr, &mut payload[..n as usize]).await;
let addr = self.addr + BTSDIO_OFFSET_HOST_READ_BUF;
bus.bp_read(addr, &mut payload[n as usize..]).await;
} else {
// no wraparound
let addr = self.addr + BTSDIO_OFFSET_HOST_READ_BUF + self.b2h_read_pointer;
bus.bp_read(addr, payload).await;
}
self.b2h_read_pointer = (self.b2h_read_pointer + payload.len() as u32) % BTSDIO_FWBUF_SIZE;
bus.bp_write32(self.addr + BTSDIO_OFFSET_BT2HOST_OUT, self.b2h_read_pointer)
.await;
buf.len = 1 + len as usize;
debug!("HCI rx: {:02x}", crate::fmt::Bytes(&buf.buf[..buf.len]));
self.rx_chan.send_done();
self.bt_toggle_intr(bus).await;
}
}
}
}
/// HCI transport error.
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Debug)]
pub enum Error {
/// I/O error.
Io(ErrorKind),
}
impl From<FromHciBytesError> for Error {
fn from(e: FromHciBytesError) -> Self {
match e {
FromHciBytesError::InvalidSize => Error::Io(ErrorKind::InvalidInput),
FromHciBytesError::InvalidValue => Error::Io(ErrorKind::InvalidData),
}
}
}
impl core::fmt::Display for Error {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
core::fmt::Debug::fmt(self, f)
}
}
impl core::error::Error for Error {}
impl<'d> embedded_io_async::ErrorType for BtDriver<'d> {
type Error = Error;
}
impl embedded_io_async::Error for Error {
fn kind(&self) -> ErrorKind {
match self {
Self::Io(e) => *e,
}
}
}
impl<'d> bt_hci::transport::Transport for BtDriver<'d> {
fn read<'a>(&self, rx: &'a mut [u8]) -> impl Future<Output = Result<ControllerToHostPacket<'a>, Self::Error>> {
async {
let ch = &mut *self.rx.borrow_mut();
let buf = ch.receive().await;
let n = buf.len;
assert!(n < rx.len());
rx[..n].copy_from_slice(&buf.buf[..n]);
ch.receive_done();
let kind = PacketKind::from_hci_bytes_complete(&rx[..1])?;
let (pkt, _) = ControllerToHostPacket::from_hci_bytes_with_kind(kind, &rx[1..n])?;
Ok(pkt)
}
}
/// Write a complete HCI packet from the tx buffer
fn write<T: HostToControllerPacket>(&self, val: &T) -> impl Future<Output = Result<(), Self::Error>> {
async {
let ch = &mut *self.tx.borrow_mut();
let buf = ch.send().await;
let buf_len = buf.buf.len();
let mut slice = &mut buf.buf[..];
WithIndicator::new(val)
.write_hci(&mut slice)
.map_err(|_| Error::Io(ErrorKind::Other))?;
buf.len = buf_len - slice.len();
ch.send_done();
Ok(())
}
}
}
================================================
FILE: cyw43/src/consts.rs
================================================
#![allow(unused)]
pub(crate) const FUNC_BUS: u32 = 0;
pub(crate) const FUNC_BACKPLANE: u32 = 1;
pub(crate) const FUNC_WLAN: u32 = 2;
pub(crate) const FUNC_BT: u32 = 3;
// Register addresses
pub(crate) const REG_BUS_CTRL: u32 = 0x0;
pub(crate) const REG_BUS_RESPONSE_DELAY: u32 = 0x1;
pub(crate) const REG_BUS_STATUS_ENABLE: u32 = 0x2;
pub(crate) const REG_BUS_INTERRUPT: u32 = 0x04; // 16 bits - Interrupt status
pub(crate) const REG_BUS_INTERRUPT_ENABLE: u32 = 0x06; // 16 bits - Interrupt mask
pub(crate) const REG_BUS_STATUS: u32 = 0x8;
pub(crate) const REG_BUS_TEST_RO: u32 = 0x14;
pub(crate) const REG_BUS_TEST_RW: u32 = 0x18;
pub(crate) const REG_BUS_RESP_DELAY: u32 = 0x1c;
// SPI_BUS_CONTROL Bits
pub(crate) const WORD_LENGTH_32: u32 = 0x1;
pub(crate) const ENDIAN_BIG: u32 = 0x2;
pub(crate) const CLOCK_PHASE: u32 = 0x4;
pub(crate) const CLOCK_POLARITY: u32 = 0x8;
pub(crate) const HIGH_SPEED: u32 = 0x10;
pub(crate) const INTERRUPT_POLARITY_HIGH: u32 = 0x20;
pub(crate) const WAKE_UP: u32 = 0x80;
// SPI_STATUS_ENABLE bits
pub(crate) const STATUS_ENABLE: u32 = 0x01;
pub(crate) const INTR_WITH_STATUS: u32 = 0x02;
pub(crate) const RESP_DELAY_ALL: u32 = 0x04;
pub(crate) const DWORD_PKT_LEN_EN: u32 = 0x08;
pub(crate) const CMD_ERR_CHK_EN: u32 = 0x20;
pub(crate) const DATA_ERR_CHK_EN: u32 = 0x40;
// SPI_STATUS_REGISTER bits
pub(crate) const SPI_STATUS_REGISTER: u32 = 0x00000008;
pub(crate) const INITIAL_READ: u32 = 0x04;
pub(crate) const STATUS_DATA_NOT_AVAILABLE: u32 = 0x00000001;
pub(crate) const STATUS_UNDERFLOW: u32 = 0x00000002;
pub(crate) const STATUS_OVERFLOW: u32 = 0x00000004;
pub(crate) const STATUS_F2_INTR: u32 = 0x00000008;
pub(crate) const STATUS_F3_INTR: u32 = 0x00000010;
pub(crate) const STATUS_F2_RX_READY: u32 = 0x00000020;
pub(crate) const STATUS_F3_RX_READY: u32 = 0x00000040;
pub(crate) const STATUS_HOST_CMD_DATA_ERR: u32 = 0x00000080;
pub(crate) const STATUS_F2_PKT_AVAILABLE: u32 = 0x00000100;
pub(crate) const STATUS_F2_PKT_LEN_MASK: u32 = 0x000FFE00;
pub(crate) const STATUS_F2_PKT_LEN_SHIFT: u32 = 9;
pub(crate) const STATUS_F3_PKT_AVAILABLE: u32 = 0x00100000;
pub(crate) const STATUS_F3_PKT_LEN_MASK: u32 = 0xFFE00000;
pub(crate) const STATUS_F3_PKT_LEN_SHIFT: u32 = 21;
pub(crate) const REG_BACKPLANE_GPIO_SELECT: u32 = 0x10005;
pub(crate) const REG_BACKPLANE_GPIO_OUTPUT: u32 = 0x10006;
pub(crate) const REG_BACKPLANE_GPIO_ENABLE: u32 = 0x10007;
pub(crate) const REG_BACKPLANE_FUNCTION2_WATERMARK: u32 = 0x10008;
pub(crate) const REG_BACKPLANE_DEVICE_CONTROL: u32 = 0x10009;
pub(crate) const REG_BACKPLANE_BACKPLANE_ADDRESS_LOW: u32 = 0x1000A;
pub(crate) const REG_BACKPLANE_BACKPLANE_ADDRESS_MID: u32 = 0x1000B;
pub(crate) const REG_BACKPLANE_BACKPLANE_ADDRESS_HIGH: u32 = 0x1000C;
pub(crate) const REG_BACKPLANE_FRAME_CONTROL: u32 = 0x1000D;
pub(crate) const REG_BACKPLANE_CHIP_CLOCK_CSR: u32 = 0x1000E;
pub(crate) const REG_BACKPLANE_PULL_UP: u32 = 0x1000F;
pub(crate) const REG_BACKPLANE_READ_FRAME_BC_LOW: u32 = 0x1001B;
pub(crate) const REG_BACKPLANE_READ_FRAME_BC_HIGH: u32 = 0x1001C;
pub(crate) const REG_BACKPLANE_WAKEUP_CTRL: u32 = 0x1001E;
pub(crate) const REG_BACKPLANE_SLEEP_CSR: u32 = 0x1001F;
pub(crate) const I_HMB_SW_MASK: u32 = 0x000000f0;
pub(crate) const I_HMB_FC_CHANGE: u32 = 1 << 5;
pub(crate) const SDIO_INT_STATUS: u32 = 0x20;
pub(crate) const SDIO_INT_HOST_MASK: u32 = 0x24;
pub(crate) const SDIO_FUNCTION_INT_MASK: u32 = 0x34;
pub(crate) const SDIO_TO_SB_MAILBOX: u32 = 0x40;
pub(crate) const SDIO_TO_SB_MAILBOX_DATA: u32 = 0x48;
pub(crate) const SDIO_TO_HOST_MAILBOX_DATA: u32 = 0x4C;
pub(crate) const SDIO_SLEEP_CSR: u32 = 0x1001F;
pub(crate) const SBSDIO_SLPCSR_KEEP_WL_KS: u32 = 1 << 0;
pub(crate) const SMB_DEV_INT: u32 = 1 << 3;
pub(crate) const SMB_INT_ACK: u32 = 1 << 1;
pub(crate) const I_HMB_HOST_INT: u32 = 1 << 7;
pub(crate) const I_HMB_DATA_FWHALT: u32 = 0x0010;
pub(crate) const HOSTINTMASK: u32 = 0x000000F0;
pub(crate) const BUS_SD_DATA_WIDTH_MASK: u32 = 0x03;
pub(crate) const BUS_SD_DATA_WIDTH_4BIT: u32 = 0x02;
pub(crate) const SDIO_SPEED_EHS: u32 = 0x02;
pub(crate) const SDIOD_CCCR_BRCM_CARDCAP_SECURE_MODE: u32 = 0x80;
pub(crate) const SBSDIO_DEVICE_CTL: u32 = 0x10009;
pub(crate) const SBSDIO_DEVCTL_ADDR_RST: u32 = 0x40;
pub(crate) const SDIO_CORE_CHIPID_REG: u32 = 0x330;
pub(crate) const SBSDIO_FUNC1_SBADDRLOW: u32 = 0x1000A;
pub(crate) const SBSDIO_FUNC1_SBADDRMID: u32 = 0x1000B;
pub(crate) const SBSDIO_FUNC1_SBADDRHIGH: u32 = 0x1000C;
pub(crate) const SPI_F2_WATERMARK: u8 = 0x20;
pub(crate) const SDIO_F2_WATERMARK: u8 = 0x08;
pub(crate) const BACKPLANE_WINDOW_SIZE: usize = 0x8000;
pub(crate) const BACKPLANE_ADDRESS_MASK: u32 = 0x7FFF;
pub(crate) const BACKPLANE_ADDRESS_32BIT_FLAG: u32 = 0x08000;
pub(crate) const BACKPLANE_MAX_TRANSFER_SIZE: usize = 64;
pub(crate) const BLOCK_BUFFER_SIZE: usize = 1024;
// Active Low Power (ALP) clock constants
pub(crate) const BACKPLANE_ALP_AVAIL_REQ: u8 = 0x08;
pub(crate) const BACKPLANE_ALP_AVAIL: u8 = 0x40;
pub(crate) const BACKPLANE_FORCE_HW_CLKREQ_OFF: u8 = 0x20;
pub(crate) const BACKPLANE_FORCE_ALP: u8 = 0x01;
pub(crate) const BACKPLANE_FORCE_HT: u32 = 0x02;
// Broadcom AMBA (Advanced Microcontroller Bus Architecture) Interconnect
// (AI) pub (crate) constants
pub(crate) const AI_IOCTRL_OFFSET: u32 = 0x408;
pub(crate) const AI_IOCTRL_BIT_FGC: u8 = 0x0002;
pub(crate) const AI_IOCTRL_BIT_CLOCK_EN: u8 = 0x0001;
pub(crate) const AI_IOCTRL_BIT_CPUHALT: u8 = 0x0020;
pub(crate) const AI_RESETCTRL_OFFSET: u32 = 0x800;
pub(crate) const AI_RESETCTRL_BIT_RESET: u8 = 1;
pub(crate) const AI_RESETSTATUS_OFFSET: u32 = 0x804;
pub(crate) const TEST_PATTERN: u32 = 0x12345678;
pub(crate) const FEEDBEAD: u32 = 0xFEEDBEAD;
// SPI_INTERRUPT_REGISTER and SPI_INTERRUPT_ENABLE_REGISTER Bits
pub(crate) const IRQ_DATA_UNAVAILABLE: u16 = 0x0001; // Requested data not available; Clear by writing a "1"
pub(crate) const IRQ_F2_F3_FIFO_RD_UNDERFLOW: u16 = 0x0002;
pub(crate) const IRQ_F2_F3_FIFO_WR_OVERFLOW: u16 = 0x0004;
pub(crate) const IRQ_COMMAND_ERROR: u16 = 0x0008; // Cleared by writing 1
pub(crate) const IRQ_DATA_ERROR: u16 = 0x0010; // Cleared by writing 1
pub(crate) const IRQ_F2_PACKET_AVAILABLE: u16 = 0x0020;
pub(crate) const IRQ_F3_PACKET_AVAILABLE: u16 = 0x0040;
pub(crate) const IRQ_F1_OVERFLOW: u16 = 0x0080; // Due to last write. Bkplane has pending write requests
pub(crate) const IRQ_MISC_INTR0: u16 = 0x0100;
pub(crate) const IRQ_MISC_INTR1: u16 = 0x0200;
pub(crate) const IRQ_MISC_INTR2: u16 = 0x0400;
pub(crate) const IRQ_MISC_INTR3: u16 = 0x0800;
pub(crate) const IRQ_MISC_INTR4: u16 = 0x1000;
pub(crate) const IRQ_F1_INTR: u16 = 0x2000;
pub(crate) const IRQ_F2_INTR: u16 = 0x4000;
pub(crate) const IRQ_F3_INTR: u16 = 0x8000;
pub(crate) const CHANNEL_TYPE_CONTROL: u8 = 0;
pub(crate) const CHANNEL_TYPE_EVENT: u8 = 1;
pub(crate) const CHANNEL_TYPE_DATA: u8 = 2;
// CYW_SPID command structure constants.
pub(crate) const WRITE: bool = true;
pub(crate) const READ: bool = false;
pub(crate) const INC_ADDR: bool = true;
pub(crate) const FIXED_ADDR: bool = false;
pub(crate) const AES_ENABLED: u32 = 0x0004;
pub(crate) const WPA2_SECURITY: u32 = 0x00400000;
pub(crate) const MIN_PSK_LEN: usize = 8;
pub(crate) const MAX_PSK_LEN: usize = 64;
// Bluetooth firmware extraction constants.
pub(crate) const BTFW_ADDR_MODE_UNKNOWN: i32 = 0;
pub(crate) const BTFW_ADDR_MODE_EXTENDED: i32 = 1;
pub(crate) const BTFW_ADDR_MODE_SEGMENT: i32 = 2;
pub(crate) const BTFW_ADDR_MODE_LINEAR32: i32 = 3;
pub(crate) const BTFW_HEX_LINE_TYPE_DATA: u8 = 0;
pub(crate) const BTFW_HEX_LINE_TYPE_END_OF_DATA: u8 = 1;
pub(crate) const BTFW_HEX_LINE_TYPE_EXTENDED_SEGMENT_ADDRESS: u8 = 2;
pub(crate) const BTFW_HEX_LINE_TYPE_EXTENDED_ADDRESS: u8 = 4;
pub(crate) const BTFW_HEX_LINE_TYPE_ABSOLUTE_32BIT_ADDRESS: u8 = 5;
// Bluetooth constants.
pub(crate) const SPI_RESP_DELAY_F1: u32 = 0x001d;
pub(crate) const WHD_BUS_SPI_BACKPLANE_READ_PADD_SIZE: u8 = 4;
pub(crate) const BT2WLAN_PWRUP_WAKE: u32 = 3;
pub(crate) const BT2WLAN_PWRUP_ADDR: u32 = 0x640894;
pub(crate) const BT_CTRL_REG_ADDR: u32 = 0x18000c7c;
pub(crate) const HOST_CTRL_REG_ADDR: u32 = 0x18000d6c;
pub(crate) const WLAN_RAM_BASE_REG_ADDR: u32 = 0x18000d68;
pub(crate) const BTSDIO_REG_DATA_VALID_BITMASK: u32 = 1 << 1;
pub(crate) const BTSDIO_REG_BT_AWAKE_BITMASK: u32 = 1 << 8;
pub(crate) const BTSDIO_REG_WAKE_BT_BITMASK: u32 = 1 << 17;
pub(crate) const BTSDIO_REG_SW_RDY_BITMASK: u32 = 1 << 24;
pub(crate) const BTSDIO_REG_FW_RDY_BITMASK: u32 = 1 << 24;
pub(crate) const BTSDIO_FWBUF_SIZE: u32 = 0x1000;
pub(crate) const BTSDIO_OFFSET_HOST_WRITE_BUF: u32 = 0;
pub(crate) const BTSDIO_OFFSET_HOST_READ_BUF: u32 = BTSDIO_FWBUF_SIZE;
pub(crate) const BTSDIO_OFFSET_HOST2BT_IN: u32 = 0x00002000;
pub(crate) const BTSDIO_OFFSET_HOST2BT_OUT: u32 = 0x00002004;
pub(crate) const BTSDIO_OFFSET_BT2HOST_IN: u32 = 0x00002008;
pub(crate) const BTSDIO_OFFSET_BT2HOST_OUT: u32 = 0x0000200C;
pub(crate) const SDIOD_CCCR_IOEN: u32 = 0x02;
pub(crate) const SDIOD_CCCR_IORDY: u32 = 0x03;
pub(crate) const SDIOD_CCCR_INTEN: u32 = 0x04;
pub(crate) const SDIOD_CCCR_BICTRL: u32 = 0x07;
pub(crate) const SDIOD_CCCR_BLKSIZE_0: u32 = 0x10;
pub(crate) const SDIOD_CCCR_SPEED_CONTROL: u32 = 0x13;
pub(crate) const SDIOD_CCCR_BRCM_CARDCAP: u32 = 0xf0;
pub(crate) const SDIOD_SEP_INT_CTL: u32 = 0xf2;
pub(crate) const SDIOD_CCCR_F1BLKSIZE_0: u32 = 0x110;
pub(crate) const SDIOD_CCCR_F2BLKSIZE_0: u32 = 0x210;
pub(crate) const SDIOD_CCCR_F2BLKSIZE_1: u32 = 0x211;
pub(crate) const INTR_CTL_MASTER_EN: u32 = 0x01;
pub(crate) const INTR_CTL_FUNC1_EN: u32 = 0x02;
pub(crate) const INTR_CTL_FUNC2_EN: u32 = 0x04;
pub(crate) const SDIO_FUNC_ENABLE_1: u32 = 0x02;
pub(crate) const SDIO_FUNC_ENABLE_2: u32 = 0x04;
pub(crate) const SDIO_FUNC_READY_1: u32 = 0x02;
pub(crate) const SDIO_FUNC_READY_2: u32 = 0x04;
pub(crate) const SDIO_64B_BLOCK: u32 = 64;
pub(crate) const SDIO_CHIP_CLOCK_CSR: u32 = 0x1000e;
pub(crate) const SDIO_PULL_UP: u32 = 0x1000f;
// SDIOD_SEP_INT_CTL bits
pub(crate) const SEP_INTR_CTL_MASK: u32 = 0x01; // out-of-band interrupt mask
pub(crate) const SEP_INTR_CTL_EN: u32 = 0x02; // out-of-band interrupt output enable
pub(crate) const SEP_INTR_CTL_POL: u32 = 0x04; // out-of-band interrupt polarity
pub(crate) const CHIPCOMMON_BASE_ADDRESS: u32 = 0x18000000;
pub(crate) const SDIO_BASE_ADDRESS: u32 = 0x18002000;
// Security type (authentication and encryption types are combined using bit mask)
#[allow(non_camel_case_types)]
#[derive(Copy, Clone, PartialEq)]
#[repr(u32)]
pub(crate) enum Security {
OPEN = 0,
WPA2_AES_PSK = WPA2_SECURITY | AES_ENABLED,
}
crate::util::enum_from_u8! {
#[allow(non_camel_case_types)]
#[derive(Copy, Clone, PartialEq)]
enum EStatus {
#[default]
Unknown = 0xFF,
/// operation was successful
SUCCESS = 0,
/// operation failed
FAIL = 1,
/// operation timed out
TIMEOUT = 2,
/// failed due to no matching network found
NO_NETWORKS = 3,
/// operation was aborted
ABORT = 4,
/// protocol failure: packet not ack'd
NO_ACK = 5,
/// AUTH or ASSOC packet was unsolicited
UNSOLICITED = 6,
/// attempt to assoc to an auto auth configuration
ATTEMPT = 7,
/// scan results are incomplete
PARTIAL = 8,
/// scan aborted by another scan
NEWSCAN = 9,
/// scan aborted due to assoc in progress
NEWASSOC = 10,
/// 802.11h quiet period started
_11HQUIET = 11,
/// user disabled scanning (WLC_SET_SCANSUPPRESS)
SUPPRESS = 12,
/// no allowable channels to scan
NOCHANS = 13,
/// scan aborted due to CCX fast roam
CCXFASTRM = 14,
/// abort channel select
CS_ABORT = 15,
}
}
impl PartialEq<EStatus> for u32 {
fn eq(&self, other: &EStatus) -> bool {
*self == *other as Self
}
}
#[allow(dead_code)]
pub(crate) struct FormatStatus(pub u32);
#[cfg(feature = "defmt")]
impl defmt::Format for FormatStatus {
fn format(&self, fmt: defmt::Formatter) {
macro_rules! implm {
($($name:ident),*) => {
$(
if self.0 & $name > 0 {
defmt::write!(fmt, " | {}", &stringify!($name)[7..]);
}
)*
};
}
implm!(
STATUS_DATA_NOT_AVAILABLE,
STATUS_UNDERFLOW,
STATUS_OVERFLOW,
STATUS_F2_INTR,
STATUS_F3_INTR,
STATUS_F2_RX_READY,
STATUS_F3_RX_READY,
STATUS_HOST_CMD_DATA_ERR,
STATUS_F2_PKT_AVAILABLE,
STATUS_F3_PKT_AVAILABLE
);
}
}
#[cfg(feature = "log")]
impl core::fmt::Debug for FormatStatus {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
macro_rules! implm {
($($name:ident),*) => {
$(
if self.0 & $name > 0 {
core::write!(fmt, " | {}", &stringify!($name)[7..])?;
}
)*
};
}
implm!(
STATUS_DATA_NOT_AVAILABLE,
STATUS_UNDERFLOW,
STATUS_OVERFLOW,
STATUS_F2_INTR,
STATUS_F3_INTR,
STATUS_F2_RX_READY,
STATUS_F3_RX_READY,
STATUS_HOST_CMD_DATA_ERR,
STATUS_F2_PKT_AVAILABLE,
STATUS_F3_PKT_AVAILABLE
);
Ok(())
}
}
#[cfg(feature = "log")]
impl core::fmt::Display for FormatStatus {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
core::fmt::Debug::fmt(self, f)
}
}
#[allow(dead_code)]
pub(crate) struct FormatInterrupt(pub u16);
#[cfg(feature = "defmt")]
impl defmt::Format for FormatInterrupt {
fn format(&self, fmt: defmt::Formatter) {
macro_rules! implm {
($($name:ident),*) => {
$(
if self.0 & $name > 0 {
defmt::write!(fmt, " | {}", &stringify!($name)[4..]);
}
)*
};
}
implm!(
IRQ_DATA_UNAVAILABLE,
IRQ_F2_F3_FIFO_RD_UNDERFLOW,
IRQ_F2_F3_FIFO_WR_OVERFLOW,
IRQ_COMMAND_ERROR,
IRQ_DATA_ERROR,
IRQ_F2_PACKET_AVAILABLE,
IRQ_F3_PACKET_AVAILABLE,
IRQ_F1_OVERFLOW,
IRQ_MISC_INTR0,
IRQ_MISC_INTR1,
IRQ_MISC_INTR2,
IRQ_MISC_INTR3,
IRQ_MISC_INTR4,
IRQ_F1_INTR,
IRQ_F2_INTR,
IRQ_F3_INTR
);
}
}
#[cfg(feature = "log")]
impl core::fmt::Debug for FormatInterrupt {
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
macro_rules! implm {
($($name:ident),*) => {
$(
if self.0 & $name > 0 {
core::write!(fmt, " | {}", &stringify!($name)[7..])?;
}
)*
};
}
implm!(
IRQ_DATA_UNAVAILABLE,
IRQ_F2_F3_FIFO_RD_UNDERFLOW,
IRQ_F2_F3_FIFO_WR_OVERFLOW,
IRQ_COMMAND_ERROR,
IRQ_DATA_ERROR,
IRQ_F2_PACKET_AVAILABLE,
IRQ_F3_PACKET_AVAILABLE,
IRQ_F1_OVERFLOW,
IRQ_MISC_INTR0,
IRQ_MISC_INTR1,
IRQ_MISC_INTR2,
IRQ_MISC_INTR3,
IRQ_MISC_INTR4,
IRQ_F1_INTR,
IRQ_F2_INTR,
IRQ_F3_INTR
);
Ok(())
}
}
#[cfg(feature = "log")]
impl core::fmt::Display for FormatInterrupt {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
core::fmt::Debug::fmt(self, f)
}
}
#[derive(Copy, Clone, Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[repr(u32)]
pub(crate) enum Ioctl {
GetMagic = 0,
GetVersion = 1,
Up = 2,
Down = 3,
GetLoop = 4,
SetLoop = 5,
Dump = 6,
GetMsglevel = 7,
SetMsglevel = 8,
GetPromisc = 9,
SetPromisc = 10,
GetRate = 12,
GetInstance = 14,
GetInfra = 19,
SetInfra = 20,
GetAuth = 21,
SetAuth = 22,
GetBssid = 23,
SetBssid = 24,
GetSsid = 25,
SetSsid = 26,
Restart = 27,
GetChannel = 29,
SetChannel = 30,
GetSrl = 31,
SetSrl = 32,
GetLrl = 33,
SetLrl = 34,
GetPlcphdr = 35,
SetPlcphdr = 36,
GetRadio = 37,
SetRadio = 38,
GetPhytype = 39,
DumpRate = 40,
SetRateParams = 41,
GetKey = 44,
SetKey = 45,
GetRegulatory = 46,
SetRegulatory = 47,
GetPassiveScan = 48,
SetPassiveScan = 49,
Scan = 50,
ScanResults = 51,
Disassoc = 52,
Reassoc = 53,
GetRoamTrigger = 54,
SetRoamTrigger = 55,
GetRoamDelta = 56,
SetRoamDelta = 57,
GetRoamScanPeriod = 58,
SetRoamScanPeriod = 59,
Evm = 60,
GetTxant = 61,
SetTxant = 62,
GetAntdiv = 63,
SetAntdiv = 64,
GetClosed = 67,
SetClosed = 68,
GetMaclist = 69,
SetMaclist = 70,
GetRateset = 71,
SetRateset = 72,
Longtrain = 74,
GetBcnprd = 75,
SetBcnprd = 76,
GetDtimprd = 77,
SetDtimprd = 78,
GetSrom = 79,
SetSrom = 80,
GetWepRestrict = 81,
SetWepRestrict = 82,
GetCountry = 83,
SetCountry = 84,
GetPm = 85,
SetPm = 86,
GetWake = 87,
SetWake = 88,
GetForcelink = 90,
SetForcelink = 91,
FreqAccuracy = 92,
CarrierSuppress = 93,
GetPhyreg = 94,
SetPhyreg = 95,
GetRadioreg = 96,
SetRadioreg = 97,
GetRevinfo = 98,
GetUcantdiv = 99,
SetUcantdiv = 100,
RReg = 101,
WReg = 102,
GetMacmode = 105,
SetMacmode = 106,
GetMonitor = 107,
SetMonitor = 108,
GetGmode = 109,
SetGmode = 110,
GetLegacyErp = 111,
SetLegacyErp = 112,
GetRxAnt = 113,
GetCurrRateset = 114,
GetScansuppress = 115,
SetScansuppress = 116,
GetAp = 117,
SetAp = 118,
GetEapRestrict = 119,
SetEapRestrict = 120,
ScbAuthorize = 121,
ScbDeauthorize = 122,
GetWdslist = 123,
SetWdslist = 124,
GetAtim = 125,
SetAtim = 126,
GetRssi = 127,
GetPhyantdiv = 128,
SetPhyantdiv = 129,
ApRxOnly = 130,
GetTxPathPwr = 131,
SetTxPathPwr = 132,
GetWsec = 133,
SetWsec = 134,
GetPhyNoise = 135,
GetBssInfo = 136,
GetPktcnts = 137,
GetLazywds = 138,
SetLazywds = 139,
GetBandlist = 140,
GetBand = 141,
SetBand = 142,
ScbDeauthenticate = 143,
GetShortslot = 144,
GetShortslotOverride = 145,
SetShortslotOverride = 146,
GetShortslotRestrict = 147,
SetShortslotRestrict = 148,
GetGmodeProtection = 149,
GetGmodeProtectionOverride = 150,
SetGmodeProtectionOverride = 151,
Upgrade = 152,
GetIgnoreBcns = 155,
SetIgnoreBcns = 156,
GetScbTimeout = 157,
SetScbTimeout = 158,
GetAssoclist = 159,
GetClk = 160,
SetClk = 161,
GetUp = 162,
Out = 163,
GetWpaAuth = 164,
SetWpaAuth = 165,
GetUcflags = 166,
SetUcflags = 167,
GetPwridx = 168,
SetPwridx = 169,
GetTssi = 170,
GetSupRatesetOverride = 171,
SetSupRatesetOverride = 172,
GetProtectionControl = 178,
SetProtectionControl = 179,
GetPhylist = 180,
EncryptStrength = 181,
DecryptStatus = 182,
GetKeySeq = 183,
GetScanChannelTime = 184,
SetScanChannelTime = 185,
GetScanUnassocTime = 186,
SetScanUnassocTime = 187,
GetScanHomeTime = 188,
SetScanHomeTime = 189,
GetScanNprobes = 190,
SetScanNprobes = 191,
GetPrbRespTimeout = 192,
SetPrbRespTimeout = 193,
GetAtten = 194,
SetAtten = 195,
GetShmem = 196,
SetShmem = 197,
SetWsecTest = 200,
ScbDeauthenticateForReason = 201,
TkipCountermeasures = 202,
GetPiomode = 203,
SetPiomode = 204,
SetAssocPrefer = 205,
GetAssocPrefer = 206,
SetRoamPrefer = 207,
GetRoamPrefer = 208,
SetLed = 209,
GetLed = 210,
GetInterferenceMode = 211,
SetInterferenceMode = 212,
GetChannelQa = 213,
StartChannelQa = 214,
GetChannelSel = 215,
StartChannelSel = 216,
GetValidChannels = 217,
GetFakefrag = 218,
SetFakefrag = 219,
GetPwroutPercentage = 220,
SetPwroutPercentage = 221,
SetBadFramePreempt = 222,
GetBadFramePreempt = 223,
SetLeapList = 224,
GetLeapList = 225,
GetCwmin = 226,
SetCwmin = 227,
GetCwmax = 228,
SetCwmax = 229,
GetWet = 230,
SetWet = 231,
GetPub = 232,
GetKeyPrimary = 235,
SetKeyPrimary = 236,
GetAciArgs = 238,
SetAciArgs = 239,
UnsetCallback = 240,
SetCallback = 241,
GetRadar = 242,
SetRadar = 243,
SetSpectManagment = 244,
GetSpectManagment = 245,
WdsGetRemoteHwaddr = 246,
WdsGetWpaSup = 247,
SetCsScanTimer = 248,
GetCsScanTimer = 249,
MeasureRequest = 250,
Init = 251,
SendQuiet = 252,
Keepalive = 253,
SendPwrConstraint = 254,
UpgradeStatus = 255,
CurrentPwr = 256,
GetScanPassiveTime = 257,
SetScanPassiveTime = 258,
LegacyLinkBehavior = 259,
GetChannelsInCountry = 260,
GetCountryList = 261,
GetVar = 262,
SetVar = 263,
NvramGet = 264,
NvramSet = 265,
NvramDump = 266,
Reboot = 267,
SetWsecPmk = 268,
GetAuthMode = 269,
SetAuthMode = 270,
GetWakeentry = 271,
SetWakeentry = 272,
NdconfigItem = 273,
Nvotpw = 274,
Otpw = 275,
IovBlockGet = 276,
IovModulesGet = 277,
SoftReset = 278,
GetAllowMode = 279,
SetAllowMode = 280,
GetDesiredBssid = 281,
SetDesiredBssid = 282,
DisassocMyap = 283,
GetNbands = 284,
GetBandstates = 285,
GetWlcBssInfo = 286,
GetAssocInfo = 287,
GetOidPhy = 288,
SetOidPhy = 289,
SetAssocTime = 290,
GetDesiredSsid = 291,
GetChanspec = 292,
GetAssocState = 293,
SetPhyState = 294,
GetScanPending = 295,
GetScanreqPending = 296,
GetPrevRoamReason = 297,
SetPrevRoamReason = 298,
GetBandstatesPi = 299,
GetPhyState = 300,
GetBssWpaRsn = 301,
GetBssWpa2Rsn = 302,
GetBssBcnTs = 303,
GetIntDisassoc = 304,
SetNumPeers = 305,
GetNumBss = 306,
GetWsecPmk = 318,
GetRandomBytes = 319,
}
pub(crate) const WSEC_TKIP: u32 = 0x02;
pub(crate) const WSEC_AES: u32 = 0x04;
pub(crate) const AUTH_OPEN: u32 = 0x00;
pub(crate) const AUTH_SAE: u32 = 0x03;
pub(crate) const MFP_NONE: u32 = 0;
pub(crate) const MFP_CAPABLE: u32 = 1;
pub(crate) const MFP_REQUIRED: u32 = 2;
pub(crate) const WPA_AUTH_DISABLED: u32 = 0x0000;
pub(crate) const WPA_AUTH_WPA_PSK: u32 = 0x0004;
pub(crate) const WPA_AUTH_WPA2_PSK: u32 = 0x0080;
pub(crate) const WPA_AUTH_WPA3_SAE_PSK: u32 = 0x40000;
================================================
FILE: cyw43/src/control.rs
================================================
use core::cmp::{max, min};
use core::iter::zip;
use core::sync::atomic::AtomicBool;
use core::sync::atomic::Ordering::Relaxed;
use embassy_net_driver_channel as ch;
use embassy_net_driver_channel::driver::HardwareAddress;
use embassy_time::{Duration, Timer};
use crate::consts::*;
use crate::events::{Event, EventSubscriber, Events};
use crate::fmt::Bytes;
use crate::ioctl::{IoctlState, IoctlType};
use crate::structs::*;
use crate::{PowerManagementMode, countries, events};
/// Join errors.
#[derive(Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum JoinError {
/// Network not found.
NetworkNotFound,
/// Failure to join network. Contains the status code from the SET_SSID event.
JoinFailure(u8),
/// Authentication failure for a secure network.
AuthenticationFailure,
}
/// Multicast errors.
#[derive(Debug)]
pub enum AddMulticastAddressError {
/// Not a multicast address.
NotMulticast,
/// No free address slots.
NoFreeSlots,
}
/// Control driver.
pub struct Control<'a> {
state_ch: ch::StateRunner<'a>,
events: &'a Events,
ioctl_state: &'a IoctlState,
secure_network: &'a AtomicBool,
}
/// WiFi scan type.
#[derive(Copy, Clone, Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum ScanType {
/// Active scan: the station actively transmits probes that make APs respond.
/// Faster, but uses more power.
Active,
/// Passive scan: the station doesn't transmit any probes, just listens for beacons.
/// Slower, but uses less power.
Passive,
}
/// Scan options.
#[derive(Clone, Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[non_exhaustive]
pub struct ScanOptions {
/// SSID to scan for.
pub ssid: Option<heapless::String<32>>,
/// If set to `None`, all APs will be returned. If set to `Some`, only APs
/// with the specified BSSID will be returned.
pub bssid: Option<[u8; 6]>,
/// Number of probes to send on each channel.
pub nprobes: Option<u16>,
/// Time to spend waiting on the home channel.
pub home_time: Option<Duration>,
/// Scan type: active or passive.
pub scan_type: ScanType,
/// Period of time to wait on each channel when passive scanning.
pub dwell_time: Option<Duration>,
}
impl Default for ScanOptions {
fn default() -> Self {
Self {
ssid: None,
bssid: None,
nprobes: None,
home_time: None,
scan_type: ScanType::Passive,
dwell_time: None,
}
}
}
/// Authentication type, used in [`JoinOptions::auth`].
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum JoinAuth {
/// Open network
Open,
/// WPA only
Wpa,
/// WPA2 only
Wpa2,
/// WPA3 only
Wpa3,
/// WPA2 + WPA3
Wpa2Wpa3,
}
/// Options for [`Control::join`].
#[derive(Clone, Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[non_exhaustive]
pub struct JoinOptions<'a> {
/// Authentication type. Default `Wpa2Wpa3`.
pub auth: JoinAuth,
/// Enable TKIP encryption. Default false.
pub cipher_tkip: bool,
/// Enable AES encryption. Default true.
pub cipher_aes: bool,
/// Passphrase. Default empty.
pub passphrase: &'a [u8],
/// If false, `passphrase` is the human-readable passphrase string.
/// If true, `passphrase` is the result of applying the PBKDF2 hash to the
/// passphrase string. This makes it possible to avoid storing unhashed passwords.
///
/// This is not compatible with WPA3.
/// Default false.
pub passphrase_is_prehashed: bool,
}
impl<'a> JoinOptions<'a> {
/// Create a new `JoinOptions` for joining open networks.
pub fn new_open() -> Self {
Self {
auth: JoinAuth::Open,
cipher_tkip: false,
cipher_aes: false,
passphrase: &[],
passphrase_is_prehashed: false,
}
}
/// Create a new `JoinOptions` for joining encrypted networks.
///
/// Defaults to supporting WPA2+WPA3 with AES only, you may edit
/// the returned options to change this.
pub fn new(passphrase: &'a [u8]) -> Self {
let mut this = Self::default();
this.passphrase = passphrase;
this
}
}
impl<'a> Default for JoinOptions<'a> {
fn default() -> Self {
Self {
auth: JoinAuth::Wpa2Wpa3,
cipher_tkip: false,
cipher_aes: true,
passphrase: &[],
passphrase_is_prehashed: false,
}
}
}
impl<'a> Control<'a> {
pub(crate) fn new(
state_ch: ch::StateRunner<'a>,
event_sub: &'a Events,
ioctl_state: &'a IoctlState,
secure_network: &'a AtomicBool,
) -> Self {
Self {
state_ch,
events: event_sub,
ioctl_state,
secure_network,
}
}
async fn load_clm(&mut self, clm: &[u8]) {
const CHUNK_SIZE: usize = 1024;
debug!("Downloading CLM...");
let mut offs = 0;
for chunk in clm.chunks(CHUNK_SIZE) {
let mut flag = DOWNLOAD_FLAG_HANDLER_VER;
if offs == 0 {
flag |= DOWNLOAD_FLAG_BEGIN;
}
offs += chunk.len();
if offs == clm.len() {
flag |= DOWNLOAD_FLAG_END;
}
let header = DownloadHeader {
flag,
dload_type: DOWNLOAD_TYPE_CLM,
len: chunk.len() as _,
crc: 0,
};
let mut buf = [0; 8 + 12 + CHUNK_SIZE];
buf[0..8].copy_from_slice(b"clmload\x00");
buf[8..20].copy_from_slice(&header.to_bytes());
buf[20..][..chunk.len()].copy_from_slice(&chunk);
self.ioctl(IoctlType::Set, Ioctl::SetVar, 0, &mut buf[..8 + 12 + chunk.len()])
.await;
}
// check clmload ok
assert_eq!(self.get_iovar_u32("clmload_status").await, 0);
}
/// Initialize WiFi controller.
pub async fn init(&mut self, clm: &[u8]) {
self.load_clm(&clm).await;
debug!("Configuring misc stuff...");
// Disable tx gloming which transfers multiple packets in one request.
// 'glom' is short for "conglomerate" which means "gather together into
// a compact mass".
self.set_iovar_u32("bus:txglom", 0).await;
self.set_iovar_u32("apsta", 1).await;
// read MAC addr.
let mac_addr = self.address().await;
debug!("mac addr: {:02x}", Bytes(&mac_addr));
let country = countries::WORLD_WIDE_XX;
let country_info = CountryInfo {
country_abbrev: [country.code[0], country.code[1], 0, 0],
country_code: [country.code[0], country.code[1], 0, 0],
rev: if country.rev == 0 { -1 } else { country.rev as _ },
};
self.set_iovar("country", &country_info.to_bytes()).await;
// set country takes some time, next ioctls fail if we don't wait.
Timer::after_millis(100).await;
// Set antenna to chip antenna
self.ioctl_set_u32(Ioctl::SetAntdiv, 0, 0).await;
self.set_iovar_u32("bus:txglom", 0).await;
Timer::after_millis(100).await;
//self.set_iovar_u32("apsta", 1).await; // this crashes, also we already did it before...??
//Timer::after_millis(100).await;
self.set_iovar_u32("ampdu_ba_wsize", 8).await;
Timer::after_millis(100).await;
self.set_iovar_u32("ampdu_mpdu", 4).await;
Timer::after_millis(100).await;
//self.set_iovar_u32("ampdu_rx_factor", 0).await; // this crashes
//Timer::after_millis(100).await;
// evts
let mut evts = EventMask {
iface: 0,
events: [0xFF; 24],
};
// Disable spammy uninteresting events.
evts.unset(Event::RADIO);
evts.unset(Event::IF);
evts.unset(Event::PROBREQ_MSG);
evts.unset(Event::PROBREQ_MSG_RX);
evts.unset(Event::PROBRESP_MSG);
evts.unset(Event::PROBRESP_MSG);
evts.unset(Event::ROAM);
self.set_iovar("bsscfg:event_msgs", &evts.to_bytes()).await;
Timer::after_millis(100).await;
// set wifi up
self.up().await;
Timer::after_millis(100).await;
self.ioctl_set_u32(Ioctl::SetGmode, 0, 1).await; // SET_GMODE = auto
self.ioctl_set_u32(Ioctl::SetBand, 0, 0).await; // SET_BAND = any
Timer::after_millis(100).await;
self.state_ch.set_hardware_address(HardwareAddress::Ethernet(mac_addr));
debug!("cyw43 control init done");
}
/// Set the WiFi interface up.
async fn up(&mut self) {
self.ioctl(IoctlType::Set, Ioctl::Up, 0, &mut []).await;
}
/// Set the interface down.
async fn down(&mut self) {
self.ioctl(IoctlType::Set, Ioctl::Down, 0, &mut []).await;
}
/// Set power management mode.
pub async fn set_power_management(&mut self, mode: PowerManagementMode) {
// power save mode
let mode_num = mode.mode();
if mode_num == 2 {
self.set_iovar_u32("pm2_sleep_ret", mode.sleep_ret_ms() as u32).await;
self.set_iovar_u32("bcn_li_bcn", mode.beacon_period() as u32).await;
self.set_iovar_u32("bcn_li_dtim", mode.dtim_period() as u32).await;
self.set_iovar_u32("assoc_listen", mode.assoc() as u32).await;
}
self.ioctl_set_u32(Ioctl::SetPm, 0, mode_num).await;
}
/// Join a network with the provided SSID using the specified options.
pub async fn join(&mut self, ssid: &str, options: JoinOptions<'_>) -> Result<(), JoinError> {
self.set_iovar_u32("ampdu_ba_wsize", 8).await;
if options.auth == JoinAuth::Open {
self.ioctl_set_u32(Ioctl::SetWsec, 0, 0).await;
self.set_iovar_u32x2("bsscfg:sup_wpa", 0, 0).await;
self.ioctl_set_u32(Ioctl::SetInfra, 0, 1).await;
self.ioctl_set_u32(Ioctl::SetAuth, 0, 0).await;
self.ioctl_set_u32(Ioctl::SetWpaAuth, 0, WPA_AUTH_DISABLED).await;
} else {
let mut wsec = 0;
if options.cipher_aes {
wsec |= WSEC_AES;
}
if options.cipher_tkip {
wsec |= WSEC_TKIP;
}
self.ioctl_set_u32(Ioctl::SetWsec, 0, wsec).await;
self.set_iovar_u32x2("bsscfg:sup_wpa", 0, 1).await;
self.set_iovar_u32x2("bsscfg:sup_wpa2_eapver", 0, 0xFFFF_FFFF).await;
self.set_iovar_u32x2("bsscfg:sup_wpa_tmo", 0, 2500).await;
Timer::after_millis(100).await;
let (wpa12, wpa3, auth, mfp, wpa_auth) = match options.auth {
JoinAuth::Open => unreachable!(),
JoinAuth::Wpa => (true, false, AUTH_OPEN, MFP_NONE, WPA_AUTH_WPA_PSK),
JoinAuth::Wpa2 => (true, false, AUTH_OPEN, MFP_CAPABLE, WPA_AUTH_WPA2_PSK),
JoinAuth::Wpa3 => (false, true, AUTH_SAE, MFP_REQUIRED, WPA_AUTH_WPA3_SAE_PSK),
JoinAuth::Wpa2Wpa3 => (true, true, AUTH_SAE, MFP_CAPABLE, WPA_AUTH_WPA3_SAE_PSK),
};
if wpa12 {
let mut flags = 0;
if !options.passphrase_is_prehashed {
flags |= 1;
}
let mut pfi = PassphraseInfo {
len: options.passphrase.len() as _,
flags,
passphrase: [0; 64],
};
pfi.passphrase[..options.passphrase.len()].copy_from_slice(options.passphrase);
Timer::after_millis(3).await;
self.ioctl(IoctlType::Set, Ioctl::SetWsecPmk, 0, &mut pfi.to_bytes())
.await;
}
if wpa3 {
let mut pfi = SaePassphraseInfo {
len: options.passphrase.len() as _,
passphrase: [0; 128],
};
pfi.passphrase[..options.passphrase.len()].copy_from_slice(options.passphrase);
Timer::after_millis(3).await;
self.set_iovar("sae_password", &pfi.to_bytes()).await;
}
self.ioctl_set_u32(Ioctl::SetInfra, 0, 1).await;
self.ioctl_set_u32(Ioctl::SetAuth, 0, auth).await;
self.set_iovar_u32("mfp", mfp).await;
self.ioctl_set_u32(Ioctl::SetWpaAuth, 0, wpa_auth).await;
}
let mut i = SsidInfo {
len: ssid.len() as _,
ssid: [0; 32],
};
i.ssid[..ssid.len()].copy_from_slice(ssid.as_bytes());
let secure_network = options.auth != JoinAuth::Open;
self.secure_network.store(secure_network, Relaxed);
self.wait_for_join(i, secure_network).await
}
async fn wait_for_join(&mut self, i: SsidInfo, secure_network: bool) -> Result<(), JoinError> {
struct UnsubscribeOnDrop<'a>(&'a Events);
impl Drop for UnsubscribeOnDrop<'_> {
fn drop(&mut self) {
self.0.mask.disable_all();
}
}
let _uod = UnsubscribeOnDrop(&self.events);
self.events.mask.enable(&[Event::SET_SSID, Event::AUTH, Event::PSK_SUP]);
let mut subscriber = self.events.queue.subscriber().unwrap();
// the actual join operation starts here
// we make sure to enable events before so we don't miss any
self.ioctl(IoctlType::Set, Ioctl::SetSsid, 0, &mut i.to_bytes()).await;
// To complete the join on an open network, we wait for a SET_SSID event with status SUCCESS
// For secured networks, we wait for a PSK_SUP event with status 6 "UNSOLICITED"
let result = loop {
let msg = subscriber.next_message_pure().await;
let status = EStatus::from(msg.header.status as u8);
match (msg.header.event_type, status, secure_network) {
// Join operation ends with SET_SSID event for open networks
(Event::SET_SSID, EStatus::SUCCESS, false) => break Ok(()),
(Event::SET_SSID, EStatus::NO_NETWORKS, _) => break Err(JoinError::NetworkNotFound),
(Event::SET_SSID, status, _) if status != EStatus::SUCCESS => {
break Err(JoinError::JoinFailure(status as u8));
}
// Ignore PSK_SUP "ABORT" which is sometimes sent before successful join
(Event::PSK_SUP, EStatus::ABORT, true) => {}
// Event PSK_SUP with status 6 "UNSOLICITED" indicates success for secure networks
(Event::PSK_SUP, EStatus::UNSOLICITED, true) => break Ok(()),
// Events indicating authentication failure, possibly due to incorrect password
(Event::PSK_SUP, _, true) | (Event::AUTH, EStatus::FAIL, true) => {
break Err(JoinError::AuthenticationFailure);
}
_ => {}
};
};
match result {
Ok(()) => debug!("JOINED"),
Err(JoinError::JoinFailure(status)) => debug!("JOIN failed: status={}", status),
Err(JoinError::NetworkNotFound) => debug!("JOIN failed: network not found"),
Err(JoinError::AuthenticationFailure) => debug!("JOIN failed: authentication failure"),
};
result
}
/// Set GPIO pin on WiFi chip.
pub async fn gpio_set(&mut self, gpio_n: u8, gpio_en: bool) {
assert!(gpio_n < 3);
self.set_iovar_u32x2("gpioout", 1 << gpio_n, if gpio_en { 1 << gpio_n } else { 0 })
.await
}
/// Start open access point.
pub async fn start_ap_open(&mut self, ssid: &str, channel: u8) {
self.start_ap(ssid, "", Security::OPEN, channel).await;
}
/// Start WPA2 protected access point.
pub async fn start_ap_wpa2(&mut self, ssid: &str, passphrase: &str, channel: u8) {
self.start_ap(ssid, passphrase, Security::WPA2_AES_PSK, channel).await;
}
async fn start_ap(&mut self, ssid: &str, passphrase: &str, security: Security, channel: u8) {
if security != Security::OPEN
&& (passphrase.as_bytes().len() < MIN_PSK_LEN || passphrase.as_bytes().len() > MAX_PSK_LEN)
{
panic!("Passphrase is too short or too long");
}
// Temporarily set wifi down
self.down().await;
// Turn off APSTA mode
self.set_iovar_u32("apsta", 0).await;
// Set wifi up again
self.up().await;
// Disable authentication
self.ioctl_set_u32(Ioctl::SetAuth, 0, AUTH_OPEN).await;
// Turn on AP mode
self.ioctl_set_u32(Ioctl::SetAp, 0, 1).await;
// Set SSID
let mut i = SsidInfoWithIndex {
index: 0,
ssid_info: SsidInfo {
len: ssid.as_bytes().len() as _,
ssid: [0; 32],
},
};
i.ssid_info.ssid[..ssid.as_bytes().len()].copy_from_slice(ssid.as_bytes());
self.set_iovar("bsscfg:ssid", &i.to_bytes()).await;
// Set channel number
self.ioctl_set_u32(Ioctl::SetChannel, 0, channel as u32).await;
// Set security
self.set_iovar_u32x2("bsscfg:wsec", 0, (security as u32) & 0xFF).await;
if security != Security::OPEN {
self.set_iovar_u32x2("bsscfg:wpa_auth", 0, 0x0084).await; // wpa_auth = WPA2_AUTH_PSK | WPA_AUTH_PSK
Timer::after_millis(100).await;
// Set passphrase
let mut pfi = PassphraseInfo {
len: passphrase.as_bytes().len() as _,
flags: 1, // WSEC_PASSPHRASE
passphrase: [0; 64],
};
pfi.passphrase[..passphrase.as_bytes().len()].copy_from_slice(passphrase.as_bytes());
self.ioctl(IoctlType::Set, Ioctl::SetWsecPmk, 0, &mut pfi.to_bytes())
.await;
}
// Change mutlicast rate from 1 Mbps to 11 Mbps
self.set_iovar_u32("2g_mrate", 11000000 / 500000).await;
// Start AP
self.set_iovar_u32x2("bss", 0, 1).await; // bss = BSS_UP
}
/// Closes access point.
pub async fn close_ap(&mut self) {
// Stop AP
self.set_iovar_u32x2("bss", 0, 0).await; // bss = BSS_DOWN
// Turn off AP mode
self.ioctl_set_u32(Ioctl::SetAp, 0, 0).await;
// Temporarily set wifi down
self.down().await;
// Turn on APSTA mode
self.set_iovar_u32("apsta", 1).await;
// Set wifi up again
self.up().await;
}
/// Add specified address to the list of hardware addresses the device
/// listens on. The address must be a Group address (I/G bit set). Up
/// to 10 addresses are supported by the firmware. Returns the number of
/// address slots filled after adding, or an error.
pub async fn add_multicast_address(&mut self, address: [u8; 6]) -> Result<usize, AddMulticastAddressError> {
// The firmware seems to ignore non-multicast addresses, so let's
// prevent the user from adding them and wasting space.
if address[0] & 0x01 != 1 {
return Err(AddMulticastAddressError::NotMulticast);
}
let mut buf = [0; 64];
self.get_iovar("mcast_list", &mut buf).await;
let n = u32::from_le_bytes(buf[..4].try_into().unwrap()) as usize;
let (used, free) = buf[4..].split_at_mut(n * 6);
if used.chunks(6).any(|a| a == address) {
return Ok(n);
}
if free.len() < 6 {
return Err(AddMulticastAddressError::NoFreeSlots);
}
free[..6].copy_from_slice(&address);
let n = n + 1;
buf[..4].copy_from_slice(&(n as u32).to_le_bytes());
self.set_iovar_v::<80>("mcast_list", &buf).await;
Ok(n)
}
/// Retrieve the list of configured multicast hardware addresses.
pub async fn list_multicast_addresses(&mut self, result: &mut [[u8; 6]; 10]) -> usize {
let mut buf = [0; 64];
self.get_iovar("mcast_list", &mut buf).await;
let n = u32::from_le_bytes(buf[..4].try_into().unwrap()) as usize;
let used = &buf[4..][..n * 6];
for (addr, output) in zip(used.chunks(6), result.iter_mut()) {
output.copy_from_slice(addr)
}
n
}
/// Retrieve the latest RSSI value
pub async fn get_rssi(&mut self) -> i32 {
let mut rssi_buf = [0u8; 4];
let n = self.ioctl(IoctlType::Get, Ioctl::GetRssi, 0, &mut rssi_buf).await;
assert_eq!(n, 4);
i32::from_ne_bytes(rssi_buf)
}
async fn set_iovar_u32x2(&mut self, name: &str, val1: u32, val2: u32) {
let mut buf = [0; 8];
buf[0..4].copy_from_slice(&val1.to_le_bytes());
buf[4..8].copy_from_slice(&val2.to_le_bytes());
self.set_iovar(name, &buf).await
}
async fn set_iovar_u32(&mut self, name: &str, val: u32) {
self.set_iovar(name, &val.to_le_bytes()).await
}
async fn get_iovar_u32(&mut self, name: &str) -> u32 {
let mut buf = [0; 4];
let len = self.get_iovar(name, &mut buf).await;
assert_eq!(len, 4);
u32::from_le_bytes(buf)
}
async fn set_iovar(&mut self, name: &str, val: &[u8]) {
self.set_iovar_v::<196>(name, val).await
}
async fn set_iovar_v<const BUFSIZE: usize>(&mut self, name: &str, val: &[u8]) {
debug!("iovar set {} = {:02x}", name, Bytes(val));
let mut buf = [0; BUFSIZE];
buf[..name.len()].copy_from_slice(name.as_bytes());
buf[name.len()] = 0;
buf[name.len() + 1..][..val.len()].copy_from_slice(val);
let total_len = name.len() + 1 + val.len();
self.ioctl_inner(IoctlType::Set, Ioctl::SetVar, 0, &mut buf[..total_len])
.await;
}
// TODO this is not really working, it always returns all zeros.
async fn get_iovar(&mut self, name: &str, res: &mut [u8]) -> usize {
debug!("iovar get {}", name);
let mut buf = [0; 64];
buf[..name.len()].copy_from_slice(name.as_bytes());
buf[name.len()] = 0;
let total_len = max(name.len() + 1, res.len());
let res_len = self
.ioctl_inner(IoctlType::Get, Ioctl::GetVar, 0, &mut buf[..total_len])
.await;
let out_len = min(res.len(), res_len);
res[..out_len].copy_from_slice(&buf[..out_len]);
out_len
}
async fn ioctl_set_u32(&mut self, cmd: Ioctl, iface: u32, val: u32) {
let mut buf = val.to_le_bytes();
self.ioctl(IoctlType::Set, cmd, iface, &mut buf).await;
}
async fn ioctl(&mut self, kind: IoctlType, cmd: Ioctl, iface: u32, buf: &mut [u8]) -> usize {
if kind == IoctlType::Set {
debug!("ioctl set {:?} iface {} = {:02x}", cmd, iface, Bytes(buf));
}
let n = self.ioctl_inner(kind, cmd, iface, buf).await;
n
}
async fn ioctl_inner(&mut self, kind: IoctlType, cmd: Ioctl, iface: u32, buf: &mut [u8]) -> usize {
struct CancelOnDrop<'a>(&'a IoctlState);
impl CancelOnDrop<'_> {
fn defuse(self) {
core::mem::forget(self);
}
}
impl Drop for CancelOnDrop<'_> {
fn drop(&mut self) {
self.0.cancel_ioctl();
}
}
let ioctl = CancelOnDrop(self.ioctl_state);
let resp_len = ioctl.0.do_ioctl(kind, cmd, iface, buf).await;
ioctl.defuse();
resp_len
}
/// Start a wifi scan
///
/// Returns a `Stream` of networks found by the device
///
/// # Note
/// Device events are currently implemented using a bounded queue.
/// To not miss any events, you should make sure to always await the stream.
pub async fn scan(&mut self, scan_opts: ScanOptions) -> Scanner<'_> {
const SCANTYPE_ACTIVE: u8 = 0;
const SCANTYPE_PASSIVE: u8 = 1;
let dwell_time = match scan_opts.dwell_time {
None => !0,
Some(t) => {
let mut t = t.as_millis() as u32;
if t == !0 {
t = !0 - 1;
}
t
}
};
let mut active_time = !0;
let mut passive_time = !0;
let scan_type = match scan_opts.scan_type {
ScanType::Active => {
active_time = dwell_time;
SCANTYPE_ACTIVE
}
ScanType::Passive => {
passive_time = dwell_time;
SCANTYPE_PASSIVE
}
};
let scan_params = ScanParams {
version: 1,
action: 1,
sync_id: 1,
ssid_len: scan_opts.ssid.as_ref().map(|e| e.as_bytes().len() as u32).unwrap_or(0),
ssid: scan_opts
.ssid
.map(|e| {
let mut ssid = [0; 32];
ssid[..e.as_bytes().len()].copy_from_slice(e.as_bytes());
ssid
})
.unwrap_or([0; 32]),
bssid: scan_opts.bssid.unwrap_or([0xff; 6]),
bss_type: 2,
scan_type,
nprobes: scan_opts.nprobes.unwrap_or(!0).into(),
active_time,
passive_time,
home_time: scan_opts.home_time.map(|e| e.as_millis() as u32).unwrap_or(!0),
channel_num: 0,
channel_list: [0; 1],
};
self.events.mask.enable(&[Event::ESCAN_RESULT]);
let subscriber = self.events.queue.subscriber().unwrap();
self.set_iovar_v::<256>("escan", &scan_params.to_bytes()).await;
Scanner {
subscriber,
events: &self.events,
}
}
/// Leave the wifi, with which we are currently associated.
pub async fn leave(&mut self) {
self.ioctl(IoctlType::Set, Ioctl::Disassoc, 0, &mut []).await;
info!("Disassociated")
}
/// Gets the MAC address of the device
pub async fn address(&mut self) -> [u8; 6] {
let mut mac_addr = [0; 6];
assert_eq!(self.get_iovar("cur_etheraddr", &mut mac_addr).await, 6);
mac_addr
}
}
/// WiFi network scanner.
pub struct Scanner<'a> {
subscriber: EventSubscriber<'a>,
events: &'a Events,
}
impl Scanner<'_> {
/// Wait for the next found network.
pub async fn next(&mut self) -> Option<BssInfo> {
let event = self.subscriber.next_message_pure().await;
if event.header.status != EStatus::PARTIAL {
self.events.mask.disable_all();
return None;
}
if let events::Payload::BssInfo(bss) = event.payload {
Some(bss)
} else {
None
}
}
}
impl Drop for Scanner<'_> {
fn drop(&mut self) {
self.events.mask.disable_all();
}
}
================================================
FILE: cyw43/src/countries.rs
================================================
#![allow(unused)]
pub struct Country {
pub code: [u8; 2],
pub rev: u16,
}
/// AF Afghanistan
pub const AFGHANISTAN: Country = Country { code: *b"AF", rev: 0 };
/// AL Albania
pub const ALBANIA: Country = Country { code: *b"AL", rev: 0 };
/// DZ Algeria
pub const ALGERIA: Country = Country { code: *b"DZ", rev: 0 };
/// AS American_Samoa
pub const AMERICAN_SAMOA: Country = Country { code: *b"AS", rev: 0 };
/// AO Angola
pub const ANGOLA: Country = Country { code: *b"AO", rev: 0 };
/// AI Anguilla
pub const ANGUILLA: Country = Country { code: *b"AI", rev: 0 };
/// AG Antigua_and_Barbuda
pub const ANTIGUA_AND_BARBUDA: Country = Country { code: *b"AG", rev: 0 };
/// AR Argentina
pub const ARGENTINA: Country = Country { code: *b"AR", rev: 0 };
/// AM Armenia
pub const ARMENIA: Country = Country { code: *b"AM", rev: 0 };
/// AW Aruba
pub const ARUBA: Country = Country { code: *b"AW", rev: 0 };
/// AU Australia
pub const AUSTRALIA: Country = Country { code: *b"AU", rev: 0 };
/// AT Austria
pub const AUSTRIA: Country = Country { code: *b"AT", rev: 0 };
/// AZ Azerbaijan
pub const AZERBAIJAN: Country = Country { code: *b"AZ", rev: 0 };
/// BS Bahamas
pub const BAHAMAS: Country = Country { code: *b"BS", rev: 0 };
/// BH Bahrain
pub const BAHRAIN: Country = Country { code: *b"BH", rev: 0 };
/// 0B Baker_Island
pub const BAKER_ISLAND: Country = Country { code: *b"0B", rev: 0 };
/// BD Bangladesh
pub const BANGLADESH: Country = Country { code: *b"BD", rev: 0 };
/// BB Barbados
pub const BARBADOS: Country = Country { code: *b"BB", rev: 0 };
/// BY Belarus
pub const BELARUS: Country = Country { code: *b"BY", rev: 0 };
/// BE Belgium
pub const BELGIUM: Country = Country { code: *b"BE", rev: 0 };
/// BZ Belize
pub const BELIZE: Country = Country { code: *b"BZ", rev: 0 };
/// BJ Benin
pub const BENIN: Country = Country { code: *b"BJ", rev: 0 };
/// BM Bermuda
pub const BERMUDA: Country = Country { code: *b"BM", rev: 0 };
/// BT Bhutan
pub const BHUTAN: Country = Country { code: *b"BT", rev: 0 };
/// BO Bolivia
pub const BOLIVIA: Country = Country { code: *b"BO", rev: 0 };
/// BA Bosnia_and_Herzegovina
pub const BOSNIA_AND_HERZEGOVINA: Country = Country { code: *b"BA", rev: 0 };
/// BW Botswana
pub const BOTSWANA: Country = Country { code: *b"BW", rev: 0 };
/// BR Brazil
pub const BRAZIL: Country = Country { code: *b"BR", rev: 0 };
/// IO British_Indian_Ocean_Territory
pub const BRITISH_INDIAN_OCEAN_TERRITORY: Country = Country { code: *b"IO", rev: 0 };
/// BN Brunei_Darussalam
pub const BRUNEI_DARUSSALAM: Country = Country { code: *b"BN", rev: 0 };
/// BG Bulgaria
pub const BULGARIA: Country = Country { code: *b"BG", rev: 0 };
/// BF Burkina_Faso
pub const BURKINA_FASO: Country = Country { code: *b"BF", rev: 0 };
/// BI Burundi
pub const BURUNDI: Country = Country { code: *b"BI", rev: 0 };
/// KH Cambodia
pub const CAMBODIA: Country = Country { code: *b"KH", rev: 0 };
/// CM Cameroon
pub const CAMEROON: Country = Country { code: *b"CM", rev: 0 };
/// CA Canada
pub const CANADA: Country = Country { code: *b"CA", rev: 0 };
/// CA Canada Revision 950
pub const CANADA_REV950: Country = Country { code: *b"CA", rev: 950 };
/// CV Cape_Verde
pub const CAPE_VERDE: Country = Country { code: *b"CV", rev: 0 };
/// KY Cayman_Islands
pub const CAYMAN_ISLANDS: Country = Country { code: *b"KY", rev: 0 };
/// CF Central_African_Republic
pub const CENTRAL_AFRICAN_REPUBLIC: Country = Country { code: *b"CF", rev: 0 };
/// TD Chad
pub const CHAD: Country = Country { code: *b"TD", rev: 0 };
/// CL Chile
pub const CHILE: Country = Country { code: *b"CL", rev: 0 };
/// CN China
pub const CHINA: Country = Country { code: *b"CN", rev: 0 };
/// CX Christmas_Island
pub const CHRISTMAS_ISLAND: Country = Country { code: *b"CX", rev: 0 };
/// CO Colombia
pub const COLOMBIA: Country = Country { code: *b"CO", rev: 0 };
/// KM Comoros
pub const COMOROS: Country = Country { code: *b"KM", rev: 0 };
/// CG Congo
pub const CONGO: Country = Country { code: *b"CG", rev: 0 };
/// CD Congo,_The_Democratic_Republic_Of_The
pub const CONGO_THE_DEMOCRATIC_REPUBLIC_OF_THE: Country = Country { code: *b"CD", rev: 0 };
/// CR Costa_Rica
pub const COSTA_RICA: Country = Country { code: *b"CR", rev: 0 };
/// CI Cote_D'ivoire
pub const COTE_DIVOIRE: Country = Country { code: *b"CI", rev: 0 };
/// HR Croatia
pub const CROATIA: Country = Country { code: *b"HR", rev: 0 };
/// CU Cuba
pub const CUBA: Country = Country { code: *b"CU", rev: 0 };
/// CY Cyprus
pub const CYPRUS: Country = Country { code: *b"CY", rev: 0 };
/// CZ Czech_Republic
pub const CZECH_REPUBLIC: Country = Country { code: *b"CZ", rev: 0 };
/// DK Denmark
pub const DENMARK: Country = Country { code: *b"DK", rev: 0 };
/// DJ Djibouti
pub const DJIBOUTI: Country = Country { code: *b"DJ", rev: 0 };
/// DM Dominica
pub const DOMINICA: Country = Country { code: *b"DM", rev: 0 };
/// DO Dominican_Republic
pub const DOMINICAN_REPUBLIC: Country = Country { code: *b"DO", rev: 0 };
/// AU G'Day mate!
pub const DOWN_UNDER: Country = Country { code: *b"AU", rev: 0 };
/// EC Ecuador
pub const ECUADOR: Country = Country { code: *b"EC", rev: 0 };
/// EG Egypt
pub const EGYPT: Country = Country { code: *b"EG", rev: 0 };
/// SV El_Salvador
pub const EL_SALVADOR: Country = Country { code: *b"SV", rev: 0 };
/// GQ Equatorial_Guinea
pub const EQUATORIAL_GUINEA: Country = Country { code: *b"GQ", rev: 0 };
/// ER Eritrea
pub const ERITREA: Country = Country { code: *b"ER", rev: 0 };
/// EE Estonia
pub const ESTONIA: Country = Country { code: *b"EE", rev: 0 };
/// ET Ethiopia
pub const ETHIOPIA: Country = Country { code: *b"ET", rev: 0 };
/// FK Falkland_Islands_(Malvinas)
pub const FALKLAND_ISLANDS_MALVINAS: Country = Country { code: *b"FK", rev: 0 };
/// FO Faroe_Islands
pub const FAROE_ISLANDS: Country = Country { code: *b"FO", rev: 0 };
/// FJ Fiji
pub const FIJI: Country = Country { code: *b"FJ", rev: 0 };
/// FI Finland
pub const FINLAND: Country = Country { code: *b"FI", rev: 0 };
/// FR France
pub const FRANCE: Country = Country { code: *b"FR", rev: 0 };
/// GF French_Guina
pub const FRENCH_GUINA: Country = Country { code: *b"GF", rev: 0 };
/// PF French_Polynesia
pub const FRENCH_POLYNESIA: Country = Country { code: *b"PF", rev: 0 };
/// TF French_Southern_Territories
pub const FRENCH_SOUTHERN_TERRITORIES: Country = Country { code: *b"TF", rev: 0 };
/// GA Gabon
pub const GABON: Country = Country { code: *b"GA", rev: 0 };
/// GM Gambia
pub const GAMBIA: Country = Country { code: *b"GM", rev: 0 };
/// GE Georgia
pub const GEORGIA: Country = Country { code: *b"GE", rev: 0 };
/// DE Germany
pub const GERMANY: Country = Country { code: *b"DE", rev: 0 };
/// E0 European_Wide Revision 895
pub const EUROPEAN_WIDE_REV895: Country = Country { code: *b"E0", rev: 895 };
/// GH Ghana
pub const GHANA: Country = Country { code: *b"GH", rev: 0 };
/// GI Gibraltar
pub const GIBRALTAR: Country = Country { code: *b"GI", rev: 0 };
/// GR Greece
pub const GREECE: Country = Country { code: *b"GR", rev: 0 };
/// GD Grenada
pub const GRENADA: Country = Country { code: *b"GD", rev: 0 };
/// GP Guadeloupe
pub const GUADELOUPE: Country = Country { code: *b"GP", rev: 0 };
/// GU Guam
pub const GUAM: Country = Country { code: *b"GU", rev: 0 };
/// GT Guatemala
pub const GUATEMALA: Country = Country { code: *b"GT", rev: 0 };
/// GG Guernsey
pub const GUERNSEY: Country = Country { code: *b"GG", rev: 0 };
/// GN Guinea
pub const GUINEA: Country = Country { code: *b"GN", rev: 0 };
/// GW Guinea-bissau
pub const GUINEA_BISSAU: Country = Country { code: *b"GW", rev: 0 };
/// GY Guyana
pub const GUYANA: Country = Country { code: *b"GY", rev: 0 };
/// HT Haiti
pub const HAITI: Country = Country { code: *b"HT", rev: 0 };
/// VA Holy_See_(Vatican_City_State)
pub const HOLY_SEE_VATICAN_CITY_STATE: Country = Country { code: *b"VA", rev: 0 };
/// HN Honduras
pub const HONDURAS: Country = Country { code: *b"HN", rev: 0 };
/// HK Hong_Kong
pub const HONG_KONG: Country = Country { code: *b"HK", rev: 0 };
/// HU Hungary
pub const HUNGARY: Country = Country { code: *b"HU", rev: 0 };
/// IS Iceland
pub const ICELAND: Country = Country { code: *b"IS", rev: 0 };
/// IN India
pub const INDIA: Country = Country { code: *b"IN", rev: 0 };
/// ID Indonesia
pub const INDONESIA: Country = Country { code: *b"ID", rev: 0 };
/// IR Iran,_Islamic_Republic_Of
pub const IRAN_ISLAMIC_REPUBLIC_OF: Country = Country { code: *b"IR", rev: 0 };
/// IQ Iraq
pub const IRAQ: Country = Country { code: *b"IQ", rev: 0 };
/// IE Ireland
pub const IRELAND: Country = Country { code: *b"IE", rev: 0 };
/// IL Israel
pub const ISRAEL: Country = Country { code: *b"IL", rev: 0 };
/// IT Italy
pub const ITALY: Country = Country { code: *b"IT", rev: 0 };
/// JM Jamaica
pub const JAMAICA: Country = Country { code: *b"JM", rev: 0 };
/// JP Japan
pub const JAPAN: Country = Country { code: *b"JP", rev: 0 };
/// JE Jersey
pub const JERSEY: Country = Country { code: *b"JE", rev: 0 };
/// JO Jordan
pub const JORDAN: Country = Country { code: *b"JO", rev: 0 };
/// KZ Kazakhstan
pub const KAZAKHSTAN: Country = Country { code: *b"KZ", rev: 0 };
/// KE Kenya
pub const KENYA: Country = Country { code: *b"KE", rev: 0 };
/// KI Kiribati
pub const KIRIBATI: Country = Country { code: *b"KI", rev: 0 };
/// KR Korea,_Republic_Of
pub const KOREA_REPUBLIC_OF: Country = Country { code: *b"KR", rev: 1 };
/// 0A Kosovo
pub const KOSOVO: Country = Country { code: *b"0A", rev: 0 };
/// KW Kuwait
pub const KUWAIT: Country = Country { code: *b"KW", rev: 0 };
/// KG Kyrgyzstan
pub const KYRGYZSTAN: Country = Country { code: *b"KG", rev: 0 };
/// LA Lao_People's_Democratic_Repubic
pub const LAO_PEOPLES_DEMOCRATIC_REPUBIC: Country = Country { code: *b"LA", rev: 0 };
/// LV Latvia
pub const LATVIA: Country = Country { code: *b"LV", rev: 0 };
/// LB Lebanon
pub const LEBANON: Country = Country { code: *b"LB", rev: 0 };
/// LS Lesotho
pub const LESOTHO: Country = Country { code: *b"LS", rev: 0 };
/// LR Liberia
pub const LIBERIA: Country = Country { code: *b"LR", rev: 0 };
/// LY Libyan_Arab_Jamahiriya
pub const LIBYAN_ARAB_JAMAHIRIYA: Country = Country { code: *b"LY", rev: 0 };
/// LI Liechtenstein
pub const LIECHTENSTEIN: Country = Country { code: *b"LI", rev: 0 };
/// LT Lithuania
pub const LITHUANIA: Country = Country { code: *b"LT", rev: 0 };
/// LU Luxembourg
pub const LUXEMBOURG: Country = Country { code: *b"LU", rev: 0 };
/// MO Macao
pub const MACAO: Country = Country { code: *b"MO", rev: 0 };
/// MK Macedonia,_Former_Yugoslav_Republic_Of
pub const MACEDONIA_FORMER_YUGOSLAV_REPUBLIC_OF: Country = Country { code: *b"MK", rev: 0 };
/// MG Madagascar
pub const MADAGASCAR: Country = Country { code: *b"MG", rev: 0 };
/// MW Malawi
pub const MALAWI: Country = Country { code: *b"MW", rev: 0 };
/// MY Malaysia
pub const MALAYSIA: Country = Country { code: *b"MY", rev: 0 };
/// MV Maldives
pub const MALDIVES: Country = Country { code: *b"MV", rev: 0 };
/// ML Mali
pub const MALI: Country = Country { code: *b"ML", rev: 0 };
/// MT Malta
pub const MALTA: Country = Country { code: *b"MT", rev: 0 };
/// IM Man,_Isle_Of
pub const MAN_ISLE_OF: Country = Country { code: *b"IM", rev: 0 };
/// MQ Martinique
pub const MARTINIQUE: Country = Country { code: *b"MQ", rev: 0 };
/// MR Mauritania
pub const MAURITANIA: Country = Country { code: *b"MR", rev: 0 };
/// MU Mauritius
pub const MAURITIUS: Country = Country { code: *b"MU", rev: 0 };
/// YT Mayotte
pub const MAYOTTE: Country = Country { code: *b"YT", rev: 0 };
/// MX Mexico
pub const MEXICO: Country = Country { code: *b"MX", rev: 0 };
/// FM Micronesia,_Federated_States_Of
pub const MICRONESIA_FEDERATED_STATES_OF: Country = Country { code: *b"FM", rev: 0 };
/// MD Moldova,_Republic_Of
pub const MOLDOVA_REPUBLIC_OF: Country = Country { code: *b"MD", rev: 0 };
/// MC Monaco
pub const MONACO: Country = Country { code: *b"MC", rev: 0 };
/// MN Mongolia
pub const MONGOLIA: Country = Country { code: *b"MN", rev: 0 };
/// ME Montenegro
pub const MONTENEGRO: Country = Country { code: *b"ME", rev: 0 };
/// MS Montserrat
pub const MONTSERRAT: Country = Country { code: *b"MS", rev: 0 };
/// MA Morocco
pub const MOROCCO: Country = Country { code: *b"MA", rev: 0 };
/// MZ Mozambique
pub const MOZAMBIQUE: Country = Country { code: *b"MZ", rev: 0 };
/// MM Myanmar
pub const MYANMAR: Country = Country { code: *b"MM", rev: 0 };
/// NA Namibia
pub const NAMIBIA: Country = Country { code: *b"NA", rev: 0 };
/// NR Nauru
pub const NAURU: Country = Country { code: *b"NR", rev: 0 };
/// NP Nepal
pub const NEPAL: Country = Country { code: *b"NP", rev: 0 };
/// NL Netherlands
pub const NETHERLANDS: Country = Country { code: *b"NL", rev: 0 };
/// AN Netherlands_Antilles
pub const NETHERLANDS_ANTILLES: Country = Country { code: *b"AN", rev: 0 };
/// NC New_Caledonia
pub const NEW_CALEDONIA: Country = Country { code: *b"NC", rev: 0 };
/// NZ New_Zealand
pub const NEW_ZEALAND: Country = Country { code: *b"NZ", rev: 0 };
/// NI Nicaragua
pub const NICARAGUA: Country = Country { code: *b"NI", rev: 0 };
/// NE Niger
pub const NIGER: Country = Country { code: *b"NE", rev: 0 };
/// NG Nigeria
pub const NIGERIA: Country = Country { code: *b"NG", rev: 0 };
/// NF Norfolk_Island
pub const NORFOLK_ISLAND: Country = Country { code: *b"NF", rev: 0 };
/// MP Northern_Mariana_Islands
pub const NORTHERN_MARIANA_ISLANDS: Country = Country { code: *b"MP", rev: 0 };
/// NO Norway
pub const NORWAY: Country = Country { code: *b"NO", rev: 0 };
/// OM Oman
pub const OMAN: Country = Country { code: *b"OM", rev: 0 };
/// PK Pakistan
pub const PAKISTAN: Country = Country { code: *b"PK", rev: 0 };
/// PW Palau
pub const PALAU: Country = Country { code: *b"PW", rev: 0 };
/// PA Panama
pub const PANAMA: Country = Country { code: *b"PA", rev: 0 };
/// PG Papua_New_Guinea
pub const PAPUA_NEW_GUINEA: Country = Country { code: *b"PG", rev: 0 };
/// PY Paraguay
pub const PARAGUAY: Country = Country { code: *b"PY", rev: 0 };
/// PE Peru
pub const PERU: Country = Country { code: *b"PE", rev: 0 };
/// PH Philippines
pub const PHILIPPINES: Country = Country { code: *b"PH", rev: 0 };
/// PL Poland
pub const POLAND: Country = Country { code: *b"PL", rev: 0 };
/// PT Portugal
pub const PORTUGAL: Country = Country { code: *b"PT", rev: 0 };
/// PR Pueto_Rico
pub const PUETO_RICO: Country = Country { code: *b"PR", rev: 0 };
/// QA Qatar
pub const QATAR: Country = Country { code: *b"QA", rev: 0 };
/// RE Reunion
pub const REUNION: Country = Country { code: *b"RE", rev: 0 };
/// RO Romania
pub const ROMANIA: Country = Country { code: *b"RO", rev: 0 };
/// RU Russian_Federation
pub const RUSSIAN_FEDERATION: Country = Country { code: *b"RU", rev: 0 };
/// RW Rwanda
pub const RWANDA: Country = Country { code: *b"RW", rev: 0 };
/// KN Saint_Kitts_and_Nevis
pub const SAINT_KITTS_AND_NEVIS: Country = Country { code: *b"KN", rev: 0 };
/// LC Saint_Lucia
pub const SAINT_LUCIA: Country = Country { code: *b"LC", rev: 0 };
/// PM Saint_Pierre_and_Miquelon
pub const SAINT_PIERRE_AND_MIQUELON: Country = Country { code: *b"PM", rev: 0 };
/// VC Saint_Vincent_and_The_Grenadines
pub const SAINT_VINCENT_AND_THE_GRENADINES: Country = Country { code: *b"VC", rev: 0 };
/// WS Samoa
pub const SAMOA: Country = Country { code: *b"WS", rev: 0 };
/// MF Sanit_Martin_/_Sint_Marteen
pub const SANIT_MARTIN_SINT_MARTEEN: Country = Country { code: *b"MF", rev: 0 };
/// ST Sao_Tome_and_Principe
pub const SAO_TOME_AND_PRINCIPE: Country = Country { code: *b"ST", rev: 0 };
/// SA Saudi_Arabia
pub const SAUDI_ARABIA: Country = Country { code: *b"SA", rev: 0 };
/// SN Senegal
pub const SENEGAL: Country = Country { code: *b"SN", rev: 0 };
/// RS Serbia
pub const SERBIA: Country = Country { code: *b"RS", rev: 0 };
/// SC Seychelles
pub const SEYCHELLES: Country = Country { code: *b"SC", rev: 0 };
/// SL Sierra_Leone
pub const SIERRA_LEONE: Country = Country { code: *b"SL", rev: 0 };
/// SG Singapore
pub const SINGAPORE: Country = Country { code: *b"SG", rev: 0 };
/// SK Slovakia
pub const SLOVAKIA: Country = Country { code: *b"SK", rev: 0 };
/// SI Slovenia
pub const SLOVENIA: Country = Country { code: *b"SI", rev: 0 };
/// SB Solomon_Islands
pub const SOLOMON_ISLANDS: Country = Country { code: *b"SB", rev: 0 };
/// SO Somalia
pub const SOMALIA: Country = Country { code: *b"SO", rev: 0 };
/// ZA South_Africa
pub const SOUTH_AFRICA: Country = Country { code: *b"ZA", rev: 0 };
/// ES Spain
pub const SPAIN: Country = Country { code: *b"ES", rev: 0 };
/// LK Sri_Lanka
pub const SRI_LANKA: Country = Country { code: *b"LK", rev: 0 };
/// SR Suriname
pub const SURINAME: Country = Country { code: *b"SR", rev: 0 };
/// SZ Swaziland
pub const SWAZILAND: Country = Country { code: *b"SZ", rev: 0 };
/// SE Sweden
pub const SWEDEN: Country = Country { code: *b"SE", rev: 0 };
/// CH Switzerland
pub const SWITZERLAND: Country = Country { code: *b"CH", rev: 0 };
/// SY Syrian_Arab_Republic
pub const SYRIAN_ARAB_REPUBLIC: Country = Country { code: *b"SY", rev: 0 };
/// TW Taiwan,_Province_Of_China
pub const TAIWAN_PROVINCE_OF_CHINA: Country = Country { code: *b"TW", rev: 0 };
/// TJ Tajikistan
pub const TAJIKISTAN: Country = Country { code: *b"TJ", rev: 0 };
/// TZ Tanzania,_United_Republic_Of
pub const TANZANIA_UNITED_REPUBLIC_OF: Country = Country { code: *b"TZ", rev: 0 };
/// TH Thailand
pub const THAILAND: Country = Country { code: *b"TH", rev: 0 };
/// TG Togo
pub const TOGO: Country = Country { code: *b"TG", rev: 0 };
/// TO Tonga
pub const TONGA: Country = Country { code: *b"TO", rev: 0 };
/// TT Trinidad_and_Tobago
pub const TRINIDAD_AND_TOBAGO: Country = Country { code: *b"TT", rev: 0 };
/// TN Tunisia
pub const TUNISIA: Country = Country { code: *b"TN", rev: 0 };
/// TR Turkey
pub const TURKEY: Country = Country { code: *b"TR", rev: 0 };
/// TM Turkmenistan
pub const TURKMENISTAN: Country = Country { code: *b"TM", rev: 0 };
/// TC Turks_and_Caicos_Islands
pub const TURKS_AND_CAICOS_ISLANDS: Country = Country { code: *b"TC", rev: 0 };
/// TV Tuvalu
pub const TUVALU: Country = Country { code: *b"TV", rev: 0 };
/// UG Uganda
pub const UGANDA: Country = Country { code: *b"UG", rev: 0 };
/// UA Ukraine
pub const UKRAINE: Country = Country { code: *b"UA", rev: 0 };
/// AE United_Arab_Emirates
pub const UNITED_ARAB_EMIRATES: Country = Country { code: *b"AE", rev: 0 };
/// GB United_Kingdom
pub const UNITED_KINGDOM: Country = Country { code: *b"GB", rev: 0 };
/// US United_States
pub const UNITED_STATES: Country = Country { code: *b"US", rev: 0 };
/// US United_States Revision 4
pub const UNITED_STATES_REV4: Country = Country { code: *b"US", rev: 4 };
/// Q1 United_States Revision 931
pub const UNITED_STATES_REV931: Country = Country { code: *b"Q1", rev: 931 };
/// Q2 United_States_(No_DFS)
pub const UNITED_STATES_NO_DFS: Country = Country { code: *b"Q2", rev: 0 };
/// UM United_States_Minor_Outlying_Islands
pub const UNITED_STATES_MINOR_OUTLYING_ISLANDS: Country = Country { code: *b"UM", rev: 0 };
/// UY Uruguay
pub const URUGUAY: Country = Country { code: *b"UY", rev: 0 };
/// UZ Uzbekistan
pub const UZBEKISTAN: Country = Country { code: *b"UZ", rev: 0 };
/// VU Vanuatu
pub const VANUATU: Country = Country { code: *b"VU", rev: 0 };
/// VE Venezuela
pub const VENEZUELA: Country = Country { code: *b"VE", rev: 0 };
/// VN Viet_Nam
pub const VIET_NAM: Country = Country { code: *b"VN", rev: 0 };
/// VG Virgin_Islands,_British
pub const VIRGIN_ISLANDS_BRITISH: Country = Country { code: *b"VG", rev: 0 };
/// VI Virgin_Islands,_U.S.
pub const VIRGIN_ISLANDS_US: Country = Country { code: *b"VI", rev: 0 };
/// WF Wallis_and_Futuna
pub const WALLIS_AND_FUTUNA: Country = Country { code: *b"WF", rev: 0 };
/// 0C West_Bank
pub const WEST_BANK: Country = Country { code: *b"0C", rev: 0 };
/// EH Western_Sahara
pub const WESTERN_SAHARA: Country = Country { code: *b"EH", rev: 0 };
/// Worldwide Locale Revision 983
pub const WORLD_WIDE_XV_REV983: Country = Country { code: *b"XV", rev: 983 };
/// Worldwide Locale (passive Ch12-14)
pub const WORLD_WIDE_XX: Country = Country { code: *b"XX", rev: 0 };
/// Worldwide Locale (passive Ch12-14) Revision 17
pub const WORLD_WIDE_XX_REV17: Country = Country { code: *b"XX", rev: 17 };
/// YE Yemen
pub const YEMEN: Country = Country { code: *b"YE", rev: 0 };
/// ZM Zambia
pub const ZAMBIA: Country = Country { code: *b"ZM", rev: 0 };
/// ZW Zimbabwe
pub const ZIMBABWE: Country = Country { code: *b"ZW", rev: 0 };
================================================
FILE: cyw43/src/events.rs
================================================
#![allow(dead_code)]
#![allow(non_camel_case_types)]
use core::cell::RefCell;
use embassy_sync::blocking_mutex::raw::NoopRawMutex;
use embassy_sync::pubsub::{PubSubChannel, Subscriber};
use crate::structs::BssInfo;
crate::util::enum_from_u8! {
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
enum Event {
#[default]
Unknown = 0xFF,
/// indicates status of set SSID
SET_SSID = 0,
/// differentiates join IBSS from found (START) IBSS
JOIN = 1,
/// STA founded an IBSS or AP started a BSS
START = 2,
/// 802.11 AUTH request
AUTH = 3,
/// 802.11 AUTH indication
AUTH_IND = 4,
/// 802.11 DEAUTH request
DEAUTH = 5,
/// 802.11 DEAUTH indication
DEAUTH_IND = 6,
/// 802.11 ASSOC request
ASSOC = 7,
/// 802.11 ASSOC indication
ASSOC_IND = 8,
/// 802.11 REASSOC request
REASSOC = 9,
/// 802.11 REASSOC indication
REASSOC_IND = 10,
/// 802.11 DISASSOC request
DISASSOC = 11,
/// 802.11 DISASSOC indication
DISASSOC_IND = 12,
/// 802.11h Quiet period started
QUIET_START = 13,
/// 802.11h Quiet period ended
QUIET_END = 14,
/// BEACONS received/lost indication
BEACON_RX = 15,
/// generic link indication
LINK = 16,
/// TKIP MIC error occurred
MIC_ERROR = 17,
/// NDIS style link indication
NDIS_LINK = 18,
/// roam attempt occurred: indicate status & reason
ROAM = 19,
/// change in dot11FailedCount (txfail)
TXFAIL = 20,
/// WPA2 pmkid cache indication
PMKID_CACHE = 21,
/// current AP's TSF value went backward
RETROGRADE_TSF = 22,
/// AP was pruned from join list for reason
PRUNE = 23,
/// report AutoAuth table entry match for join attempt
AUTOAUTH = 24,
/// Event encapsulating an EAPOL message
EAPOL_MSG = 25,
/// Scan results are ready or scan was aborted
SCAN_COMPLETE = 26,
/// indicate to host addts fail/success
ADDTS_IND = 27,
/// indicate to host delts fail/success
DELTS_IND = 28,
/// indicate to host of beacon transmit
BCNSENT_IND = 29,
/// Send the received beacon up to the host
BCNRX_MSG = 30,
/// indicate to host loss of beacon
BCNLOST_MSG = 31,
/// before attempting to roam
ROAM_PREP = 32,
/// PFN network found event
PFN_NET_FOUND = 33,
/// PFN network lost event
PFN_NET_LOST = 34,
RESET_COMPLETE = 35,
JOIN_START = 36,
ROAM_START = 37,
ASSOC_START = 38,
IBSS_ASSOC = 39,
RADIO = 40,
/// PSM microcode watchdog fired
PSM_WATCHDOG = 41,
/// CCX association start
CCX_ASSOC_START = 42,
/// CCX association abort
CCX_ASSOC_ABORT = 43,
/// probe request received
PROBREQ_MSG = 44,
SCAN_CONFIRM_IND = 45,
/// WPA Handshake
PSK_SUP = 46,
COUNTRY_CODE_CHANGED = 47,
/// WMMAC excedded medium time
EXCEEDED_MEDIUM_TIME = 48,
/// WEP ICV error occurred
ICV_ERROR = 49,
/// Unsupported unicast encrypted frame
UNICAST_DECODE_ERROR = 50,
/// Unsupported multicast encrypted frame
MULTICAST_DECODE_ERROR = 51,
TRACE = 52,
/// BT-AMP HCI event
BTA_HCI_EVENT = 53,
/// I/F change (for wlan host notification)
IF = 54,
/// P2P Discovery listen state expires
P2P_DISC_LISTEN_COMPLETE = 55,
/// indicate RSSI change based on configured levels
RSSI = 56,
/// PFN best network batching event
PFN_BEST_BATCHING = 57,
EXTLOG_MSG = 58,
/// Action frame reception
ACTION_FRAME = 59,
/// Action frame Tx complete
ACTION_FRAME_COMPLETE = 60,
/// assoc request received
PRE_ASSOC_IND = 61,
/// re-assoc request received
PRE_REASSOC_IND = 62,
/// channel adopted (xxx: obsoleted)
CHANNEL_ADOPTED = 63,
/// AP started
AP_STARTED = 64,
/// AP stopped due to DFS
DFS_AP_STOP = 65,
/// AP resumed due to DFS
DFS_AP_RESUME = 66,
/// WAI stations event
WAI_STA_EVENT = 67,
/// event encapsulating an WAI message
WAI_MSG = 68,
/// escan result event
ESCAN_RESULT = 69,
/// action frame off channel complete
ACTION_FRAME_OFF_CHAN_COMPLETE = 70,
/// probe response received
PROBRESP_MSG = 71,
/// P2P Probe request received
P2P_PROBREQ_MSG = 72,
DCS_REQUEST = 73,
/// credits for D11 FIFOs. [AC0,AC1,AC2,AC3,BC_MC,ATIM]
FIFO_CREDIT_MAP = 74,
/// Received action frame event WITH wl_event_rx_frame_data_t header
ACTION_FRAME_RX = 75,
/// Wake Event timer fired, used for wake WLAN test mode
WAKE_EVENT = 76,
/// Radio measurement complete
RM_COMPLETE = 77,
/// Synchronize TSF with the host
HTSFSYNC = 78,
/// request an overlay IOCTL/iovar from the host
OVERLAY_REQ = 79,
CSA_COMPLETE_IND = 80,
/// excess PM Wake Event to inform host
EXCESS_PM_WAKE_EVENT = 81,
/// no PFN networks around
PFN_SCAN_NONE = 82,
/// last found PFN network gets lost
PFN_SCAN_ALLGONE = 83,
GTK_PLUMBED = 84,
/// 802.11 ASSOC indication for NDIS only
ASSOC_IND_NDIS = 85,
/// 802.11 REASSOC indication for NDIS only
REASSOC_IND_NDIS = 86,
ASSOC_REQ_IE = 87,
ASSOC_RESP_IE = 88,
/// association recreated on resume
ASSOC_RECREATED = 89,
/// rx action frame event for NDIS only
ACTION_FRAME_RX_NDIS = 90,
/// authentication request received
AUTH_REQ = 91,
/// fast assoc recreation failed
SPEEDY_RECREATE_FAIL = 93,
/// port-specific event and payload (e.g. NDIS)
NATIVE = 94,
/// event for tx pkt delay suddently jump
PKTDELAY_IND = 95,
/// AWDL AW period starts
AWDL_AW = 96,
/// AWDL Master/Slave/NE master role event
AWDL_ROLE = 97,
/// Generic AWDL event
AWDL_EVENT = 98,
/// NIC AF txstatus
NIC_AF_TXS = 99,
/// NAN event
NAN = 100,
BEACON_FRAME_RX = 101,
/// desired service found
SERVICE_FOUND = 102,
/// GAS fragment received
GAS_FRAGMENT_RX = 103,
/// GAS sessions all complete
GAS_COMPLETE = 104,
/// New device found by p2p offload
P2PO_ADD_DEVICE = 105,
/// device has been removed by p2p offload
P2PO_DEL_DEVICE = 106,
/// WNM event to notify STA enter sleep mode
WNM_STA_SLEEP = 107,
/// Indication of MAC tx failures (exhaustion of 802.11 retries) exceeding threshold(s)
TXFAIL_THRESH = 108,
/// Proximity Detection event
PROXD = 109,
/// AWDL RX Probe response
AWDL_RX_PRB_RESP = 111,
/// AWDL RX Action Frames
AWDL_RX_ACT_FRAME = 112,
/// AWDL Wowl nulls
AWDL_WOWL_NULLPKT = 113,
/// AWDL Phycal status
AWDL_PHYCAL_STATUS = 114,
/// AWDL OOB AF status
AWDL_OOB_AF_STATUS = 115,
/// Interleaved Scan status
AWDL_SCAN_STATUS = 116,
/// AWDL AW Start
AWDL_AW_START = 117,
/// AWDL AW End
AWDL_AW_END = 118,
/// AWDL AW Extensions
AWDL_AW_EXT = 119,
AWDL_PEER_CACHE_CONTROL = 120,
CSA_START_IND = 121,
CSA_DONE_IND = 122,
CSA_FAILURE_IND = 123,
/// CCA based channel quality report
CCA_CHAN_QUAL = 124,
/// to report change in BSSID while roaming
BSSID = 125,
/// tx error indication
TX_STAT_ERROR = 126,
/// credit check for BCMC supported
BCMC_CREDIT_SUPPORT = 127,
/// psta primary interface indication
PSTA_PRIMARY_INTF_IND = 128,
/// Handover Request Initiated
BT_WIFI_HANDOVER_REQ = 130,
/// Southpaw TxInhibit notification
SPW_TXINHIBIT = 131,
/// FBT Authentication Request Indication
FBT_AUTH_REQ_IND = 132,
/// Enhancement addition for RSSI
RSSI_LQM = 133,
/// Full probe/beacon (IEs etc) results
PFN_GSCAN_FULL_RESULT = 134,
/// Significant change in rssi of bssids being tracked
PFN_SWC = 135,
/// a STA been authroized for traffic
AUTHORIZED = 136,
/// probe req with wl_event_rx_frame_data_t header
PROBREQ_MSG_RX = 137,
/// PFN completed scan of network list
PFN_SCAN_COMPLETE = 138,
/// RMC Event
RMC_EVENT = 139,
/// DPSTA interface indication
DPSTA_INTF_IND = 140,
/// RRM Event
RRM = 141,
/// ULP entry event
ULP = 146,
/// TCP Keep Alive Offload Event
TKO = 151,
/// authentication request received
EXT_AUTH_REQ = 187,
/// authentication request received
EXT_AUTH_FRAME_RX = 188,
/// mgmt frame Tx complete
MGMT_FRAME_TXSTATUS = 189,
/// highest val + 1 for range checking
LAST = 190,
}
}
// TODO this PubSub can probably be replaced with shared memory to make it a bit more efficient.
pub type EventQueue = PubSubChannel<NoopRawMutex, Message, 2, 1, 1>;
pub type EventSubscriber<'a> = Subscriber<'a, NoopRawMutex, Message, 2, 1, 1>;
pub struct Events {
pub queue: EventQueue,
pub mask: SharedEventMask,
}
impl Events {
pub const fn new() -> Self {
Self {
queue: EventQueue::new(),
mask: SharedEventMask::new(),
}
}
}
#[derive(Clone, Copy)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct Status {
pub event_type: Event,
pub status: u32,
}
#[derive(Copy, Clone)]
pub enum Payload {
None,
BssInfo(BssInfo),
}
#[derive(Copy, Clone)]
pub struct Message {
pub header: Status,
pub payload: Payload,
}
impl Message {
pub fn new(status: Status, payload: Payload) -> Self {
Self {
header: status,
payload,
}
}
}
struct EventMask {
mask: [u32; Self::WORD_COUNT],
}
impl EventMask {
const WORD_COUNT: usize = ((Event::LAST as u32 + (u32::BITS - 1)) / u32::BITS) as usize;
const fn new() -> Self {
Self {
mask: [0; Self::WORD_COUNT],
}
}
fn enable(&mut self, event: Event) {
let n = event as u32;
let word = n / u32::BITS;
let bit = n % u32::BITS;
self.mask[word as usize] |= 1 << bit;
}
fn disable(&mut self, event: Event) {
let n = event as u32;
let word = n / u32::BITS;
let bit = n % u32::BITS;
self.mask[word as usize] &= !(1 << bit);
}
fn is_enabled(&self, event: Event) -> bool {
let n = event as u32;
let word = n / u32::BITS;
let bit = n % u32::BITS;
self.mask[word as usize] & (1 << bit) > 0
}
}
pub struct SharedEventMask {
mask: RefCell<EventMask>,
}
impl SharedEventMask {
pub const fn new() -> Self {
Self {
mask: RefCell::new(EventMask::new()),
}
}
pub fn enable(&self, events: &[Event]) {
let mut mask = self.mask.borrow_mut();
for event in events {
mask.enable(*event);
}
}
#[allow(dead_code)]
pub fn disable(&self, events: &[Event]) {
let mut mask = self.mask.borrow_mut();
for event in events {
mask.disable(*event);
}
}
pub fn disable_all(&self) {
let mut mask = self.mask.borrow_mut();
mask.mask = Default::default();
}
pub fn is_enabled(&self, event: Event) -> bool {
let mask = self.mask.borrow();
mask.is_enabled(event)
}
}
impl Default for SharedEventMask {
fn default() -> Self {
Self::new()
}
}
================================================
FILE: cyw43/src/fmt.rs
================================================
#![macro_use]
#![allow(unused)]
use core::fmt::{Debug, Display, LowerHex};
#[cfg(all(feature = "defmt", feature = "log"))]
compile_error!("You may not enable both `defmt` and `log` features.");
#[collapse_debuginfo(yes)]
macro_rules! assert {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
::core::assert!($($x)*);
#[cfg(feature = "defmt")]
::defmt::assert!($($x)*);
}
};
}
#[collapse_debuginfo(yes)]
macro_rules! assert_eq {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
::core::assert_eq!($($x)*);
#[cfg(feature = "defmt")]
::defmt::assert_eq!($($x)*);
}
};
}
#[collapse_debuginfo(yes)]
macro_rules! assert_ne {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
::core::assert_ne!($($x)*);
#[cfg(feature = "defmt")]
::defmt::assert_ne!($($x)*);
}
};
}
#[collapse_debuginfo(yes)]
macro_rules! debug_assert {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
::core::debug_assert!($($x)*);
#[cfg(feature = "defmt")]
::defmt::debug_assert!($($x)*);
}
};
}
#[collapse_debuginfo(yes)]
macro_rules! debug_assert_eq {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
::core::debug_assert_eq!($($x)*);
#[cfg(feature = "defmt")]
::defmt::debug_assert_eq!($($x)*);
}
};
}
#[collapse_debuginfo(yes)]
macro_rules! debug_assert_ne {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
::core::debug_assert_ne!($($x)*);
#[cfg(feature = "defmt")]
::defmt::debug_assert_ne!($($x)*);
}
};
}
#[collapse_debuginfo(yes)]
macro_rules! todo {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
::core::todo!($($x)*);
#[cfg(feature = "defmt")]
::defmt::todo!($($x)*);
}
};
}
#[collapse_debuginfo(yes)]
macro_rules! unreachable {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
::core::unreachable!($($x)*);
#[cfg(feature = "defmt")]
::defmt::unreachable!($($x)*);
}
};
}
#[collapse_debuginfo(yes)]
macro_rules! panic {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
::core::panic!($($x)*);
#[cfg(feature = "defmt")]
::defmt::panic!($($x)*);
}
};
}
#[collapse_debuginfo(yes)]
macro_rules! trace {
($s:literal $(, $x:expr)* $(,)?) => {
{
#[cfg(feature = "log")]
::log::trace!($s $(, $x)*);
#[cfg(feature = "defmt")]
::defmt::trace!($s $(, $x)*);
#[cfg(not(any(feature = "log", feature="defmt")))]
let _ = ($( & $x ),*);
}
};
}
#[collapse_debuginfo(yes)]
macro_rules! debug {
($s:literal $(, $x:expr)* $(,)?) => {
{
#[cfg(feature = "log")]
::log::debug!($s $(, $x)*);
#[cfg(feature = "defmt")]
::defmt::debug!($s $(, $x)*);
#[cfg(not(any(feature = "log", feature="defmt")))]
let _ = ($( & $x ),*);
}
};
}
#[collapse_debuginfo(yes)]
macro_rules! info {
($s:literal $(, $x:expr)* $(,)?) => {
{
#[cfg(feature = "log")]
::log::info!($s $(, $x)*);
#[cfg(feature = "defmt")]
::defmt::info!($s $(, $x)*);
#[cfg(not(any(feature = "log", feature="defmt")))]
let _ = ($( & $x ),*);
}
};
}
#[collapse_debuginfo(yes)]
macro_rules! warn {
($s:literal $(, $x:expr)* $(,)?) => {
{
#[cfg(feature = "log")]
::log::warn!($s $(, $x)*);
#[cfg(feature = "defmt")]
::defmt::warn!($s $(, $x)*);
#[cfg(not(any(feature = "log", feature="defmt")))]
let _ = ($( & $x ),*);
}
};
}
#[collapse_debuginfo(yes)]
macro_rules! error {
($s:literal $(, $x:expr)* $(,)?) => {
{
#[cfg(feature = "log")]
::log::error!($s $(, $x)*);
#[cfg(feature = "defmt")]
::defmt::error!($s $(, $x)*);
#[cfg(not(any(feature = "log", feature="defmt")))]
let _ = ($( & $x ),*);
}
};
}
#[cfg(feature = "defmt")]
#[collapse_debuginfo(yes)]
macro_rules! unwrap {
($($x:tt)*) => {
::defmt::unwrap!($($x)*)
};
}
#[cfg(not(feature = "defmt"))]
#[collapse_debuginfo(yes)]
macro_rules! unwrap {
($arg:expr) => {
match $crate::fmt::Try::into_result($arg) {
::core::result::Result::Ok(t) => t,
::core::result::Result::Err(e) => {
::core::panic!("unwrap of `{}` failed: {:?}", ::core::stringify!($arg), e);
}
}
};
($arg:expr, $($msg:expr),+ $(,)? ) => {
match $crate::fmt::Try::into_result($arg) {
::core::result::Result::Ok(t) => t,
::core::result::Result::Err(e) => {
::core::panic!("unwrap of `{}` failed: {}: {:?}", ::core::stringify!($arg), ::core::format_args!($($msg,)*), e);
}
}
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct NoneError;
pub trait Try {
type Ok;
type Error;
fn into_result(self) -> Result<Self::Ok, Self::Error>;
}
impl<T> Try for Option<T> {
type Ok = T;
type Error = NoneError;
#[inline]
fn into_result(self) -> Result<T, NoneError> {
self.ok_or(NoneError)
}
}
impl<T, E> Try for Result<T, E> {
type Ok = T;
type Error = E;
#[inline]
fn into_result(self) -> Self {
self
}
}
pub(crate) struct Bytes<'a>(pub &'a [u8]);
impl<'a> Debug for Bytes<'a> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{:#02x?}", self.0)
}
}
impl<'a> Display for Bytes<'a> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{:#02x?}", self.0)
}
}
impl<'a> LowerHex for Bytes<'a> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{:#02x?}", self.0)
}
}
#[cfg(feature = "defmt")]
impl<'a> defmt::Format for Bytes<'a> {
fn format(&self, fmt: defmt::Formatter) {
defmt::write!(fmt, "{:02x}", self.0)
}
}
================================================
FILE: cyw43/src/ioctl.rs
================================================
use core::cell::{Cell, RefCell};
use core::future::{Future, poll_fn};
use core::task::{Poll, Waker};
use embassy_sync::waitqueue::WakerRegistration;
use crate::consts::Ioctl;
use crate::fmt::Bytes;
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum IoctlType {
Get = 0,
Set = 2,
}
#[derive(Clone, Copy)]
pub struct PendingIoctl {
pub buf: *mut [u8],
pub kind: IoctlType,
pub cmd: Ioctl,
pub iface: u32,
}
#[derive(Clone, Copy)]
enum IoctlStateInner {
Pending(PendingIoctl),
Sent { buf: *mut [u8] },
Done { resp_len: usize },
}
struct Wakers {
control: WakerRegistration,
runner: WakerRegistration,
}
impl Wakers {
const fn new() -> Self {
Self {
control: WakerRegistration::new(),
runner: WakerRegistration::new(),
}
}
}
pub struct IoctlState {
state: Cell<IoctlStateInner>,
wakers: RefCell<Wakers>,
}
impl IoctlState {
pub const fn new() -> Self {
Self {
state: Cell::new(IoctlStateInner::Done { resp_len: 0 }),
wakers: RefCell::new(Wakers::new()),
}
}
fn wake_control(&self) {
self.wakers.borrow_mut().control.wake();
}
fn register_control(&self, waker: &Waker) {
self.wakers.borrow_mut().control.register(waker);
}
fn wake_runner(&self) {
self.wakers.borrow_mut().runner.wake();
}
fn register_runner(&self, waker: &Waker) {
self.wakers.borrow_mut().runner.register(waker);
}
pub fn wait_complete(&self) -> impl Future<Output = usize> + '_ {
poll_fn(|cx| {
if let IoctlStateInner::Done { resp_len } = self.state.get() {
Poll::Ready(resp_len)
} else {
self.register_control(cx.waker());
Poll::Pending
}
})
}
pub fn wait_pending(&self) -> impl Future<Output = PendingIoctl> + '_ {
poll_fn(|cx| {
if let IoctlStateInner::Pending(pending) = self.state.get() {
self.state.set(IoctlStateInner::Sent { buf: pending.buf });
Poll::Ready(pending)
} else {
self.register_runner(cx.waker());
Poll::Pending
}
})
}
pub fn cancel_ioctl(&self) {
self.state.set(IoctlStateInner::Done { resp_len: 0 });
}
pub async fn do_ioctl(&self, kind: IoctlType, cmd: Ioctl, iface: u32, buf: &mut [u8]) -> usize {
self.state
.set(IoctlStateInner::Pending(PendingIoctl { buf, kind, cmd, iface }));
self.wake_runner();
self.wait_complete().await
}
pub fn ioctl_done(&self, response: &[u8]) {
if let IoctlStateInner::Sent { buf } = self.state.get() {
trace!("IOCTL Response: {:02x}", Bytes(response));
// TODO fix this
(unsafe { &mut *buf }[..response.len()]).copy_from_slice(response);
self.state.set(IoctlStateInner::Done {
resp_len: response.len(),
});
self.wake_control();
} else {
warn!("IOCTL Response but no pending Ioctl");
}
}
}
================================================
FILE: cyw43/src/lib.rs
================================================
#![no_std]
#![no_main]
#![allow(async_fn_in_trait)]
#![allow(unsafe_op_in_unsafe_fn)]
#![deny(unused_must_use)]
#![doc = include_str!("../README.md")]
#![warn(missing_docs)]
// This mod MUST go first, so that the others see its macros.
pub(crate) mod fmt;
#[cfg(feature = "bluetooth")]
/// Bluetooth module.
pub mod bluetooth;
mod consts;
mod control;
mod countries;
mod events;
mod ioctl;
mod runner;
mod sdio;
mod spi;
mod structs;
mod util;
use core::sync::atomic::AtomicBool;
pub use aligned::{A4, Aligned};
use embassy_net_driver_channel as ch;
use embedded_hal_1::digital::OutputPin;
use events::Events;
use ioctl::IoctlState;
pub use crate::control::{
AddMulticastAddressError, Control, JoinAuth, JoinError, JoinOptions, ScanOptions, ScanType, Scanner,
};
pub use crate::runner::Runner;
pub use crate::sdio::{SdioBus, SdioBusCyw43};
pub use crate::spi::{SpiBus, SpiBusCyw43};
pub use crate::structs::BssInfo;
const MTU: usize = 1514;
#[allow(unused)]
#[derive(Clone, Copy, PartialEq, Eq)]
enum Core {
WLAN = 0,
SOCSRAM = 1,
SDIOD = 2,
}
impl Core {
fn base_addr(&self) -> u32 {
match self {
Self::WLAN => CHIP.arm_core_base_address,
Self::SOCSRAM => CHIP.socsram_wrapper_base_address,
Self::SDIOD => CHIP.sdiod_core_base_address,
}
}
}
#[allow(unused)]
struct Chip {
arm_core_base_address: u32,
socsram_base_address: u32,
bluetooth_base_address: u32,
socsram_wrapper_base_address: u32,
sdiod_core_base_address: u32,
pmu_base_address: u32,
chip_ram_size: u32,
atcm_ram_base_address: u32,
socram_srmem_size: u32,
chanspec_band_mask: u32,
chanspec_band_2g: u32,
chanspec_band_5g: u32,
chanspec_band_shift: u32,
chanspec_bw_10: u32,
chanspec_bw_20: u32,
chanspec_bw_40: u32,
chanspec_bw_mask: u32,
chanspec_bw_shift: u32,
chanspec_ctl_sb_lower: u32,
chanspec_ctl_sb_upper: u32,
chanspec_ctl_sb_none: u32,
chanspec_ctl_sb_mask: u32,
}
const WRAPPER_REGISTER_OFFSET: u32 = 0x100000;
// Data for CYW43439
const CHIP: Chip = Chip {
arm_core_base_address: 0x18003000 + WRAPPER_REGISTER_OFFSET,
socsram_base_address: 0x18004000,
bluetooth_base_address: 0x19000000,
socsram_wrapper_base_address: 0x18004000 + WRAPPER_REGISTER_OFFSET,
sdiod_core_base_address: 0x18002000,
pmu_base_address: 0x18000000,
chip_ram_size: 512 * 1024,
atcm_ram_base_address: 0,
socram_srmem_size: 64 * 1024,
chanspec_band_mask: 0xc000,
chanspec_band_2g: 0x0000,
chanspec_band_5g: 0xc000,
chanspec_band_shift: 14,
chanspec_bw_10: 0x0800,
chanspec_bw_20: 0x1000,
chanspec_bw_40: 0x1800,
chanspec_bw_mask: 0x3800,
chanspec_bw_shift: 11,
chanspec_ctl_sb_lower: 0x0000,
chanspec_ctl_sb_upper: 0x0100,
chanspec_ctl_sb_none: 0x0000,
chanspec_ctl_sb_mask: 0x0700,
};
/// Driver state.
pub struct State {
ioctl_state: IoctlState,
net: NetState,
#[cfg(feature = "bluetooth")]
bt: bluetooth::BtState,
}
struct NetState {
ch: ch::State<MTU, 4, 4>,
events: Events,
secure_network: AtomicBool,
}
impl State {
/// Create new driver state holder.
pub const fn new() -> Self {
Self {
ioctl_state: IoctlState::new(),
net: NetState {
ch: ch::State::new(),
events: Events::new(),
secure_network: AtomicBool::new(false),
},
#[cfg(feature = "bluetooth")]
bt: bluetooth::BtState::new(),
}
}
}
/// Power management modes.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PowerManagementMode {
/// Custom, officially unsupported mode. Use at your own risk.
/// All power-saving features set to their max at only a marginal decrease in power consumption
/// as oppposed to `Aggressive`.
SuperSave,
/// Aggressive power saving mode.
Aggressive,
/// The default mode.
PowerSave,
/// Performance is prefered over power consumption but still some power is conserved as opposed to
/// `None`.
Performance,
/// Unlike all the other PM modes, this lowers the power consumption at all times at the cost of
/// a much lower throughput.
ThroughputThrottling,
/// No power management is configured. This consumes the most power.
None,
}
impl Default for PowerManagementMode {
fn default() -> Self {
Self::PowerSave
}
}
impl PowerManagementMode {
fn sleep_ret_ms(&self) -> u16 {
match self {
PowerManagementMode::SuperSave => 2000,
PowerManagementMode::Aggressive => 2000,
PowerManagementMode::PowerSave => 200,
PowerManagementMode::Performance => 20,
PowerManagementMode::ThroughputThrottling => 0, // value doesn't matter
PowerManagementMode::None => 0, // value doesn't matter
}
}
fn beacon_period(&self) -> u8 {
match self {
PowerManagementMode::SuperSave => 255,
PowerManagementMode::Aggressive => 1,
PowerManagementMode::PowerSave => 1,
PowerManagementMode::Performance => 1,
PowerManagementMode::ThroughputThrottling => 0, // value doesn't matter
PowerManagementMode::None => 0, // value doesn't matter
}
}
fn dtim_period(&self) -> u8 {
match self {
PowerManagementMode::SuperSave => 255,
PowerManagementMode::Aggressive => 1,
PowerManagementMode::PowerSave => 1,
PowerManagementMode::Performance => 1,
PowerManagementMode::ThroughputThrottling => 0, // value doesn't matter
PowerManagementMode::None => 0, // value doesn't matter
}
}
fn assoc(&self) -> u8 {
match self {
PowerManagementMode::SuperSave => 255,
PowerManagementMode::Aggressive => 10,
PowerManagementMode::PowerSave => 10,
PowerManagementMode::Performance => 1,
PowerManagementMode::ThroughputThrottling => 0, // value doesn't matter
PowerManagementMode::None => 0, // value doesn't matter
}
}
fn mode(&self) -> u32 {
match self {
PowerManagementMode::ThroughputThrottling => 1,
PowerManagementMode::None => 0,
_ => 2,
}
}
}
/// Embassy-net driver.
pub type NetDriver<'a> = ch::Device<'a, MTU>;
/// Create a new instance of the CYW43 driver.
///
/// Returns a handle to the network device, control handle and a runner for driving the low level
/// stack.
pub async fn new<'a, PWR, SPI>(
state: &'a mut State,
pwr: PWR,
spi: SPI,
firmware: &Aligned<A4, [u8]>,
nvram: &Aligned<A4, [u8]>,
) -> (NetDriver<'a>, Control<'a>, Runner<'a, SpiBus<PWR, SPI>>)
where
PWR: OutputPin,
SPI: SpiBusCyw43,
{
let (ch_runner, device) = ch::new(&mut state.net.ch, ch::driver::HardwareAddress::Ethernet([0; 6]));
let state_ch = ch_runner.state_runner();
let mut runner = Runner::new(
ch_runner,
SpiBus::new(pwr, spi),
&state.ioctl_state,
&state.net.events,
&state.net.secure_network,
#[cfg(feature = "bluetooth")]
None,
);
runner.init(firmware, nvram, None).await.unwrap();
let control = Control::new(
state_ch,
&state.net.events,
&state.ioctl_state,
&state.net.secure_network,
);
(device, control, runner)
}
/// Create a new instance of the CYW43 driver.
///
/// Returns a handle to the network device, control handle and a runner for driving the low level
/// stack.
pub async fn new_sdio<'a, SDIO>(
state: &'a mut State,
sdio: SDIO,
firmware: &Aligned<A4, [u8]>,
nvram: &Aligned<A4, [u8]>,
) -> (NetDriver<'a>, Control<'a>, Runner<'a, SdioBus<SDIO>>)
where
SDIO: SdioBusCyw43<64>,
{
let (ch_runner, device) = ch::new(&mut state.net.ch, ch::driver::HardwareAddress::Ethernet([0; 6]));
let state_ch = ch_runner.state_runner();
let mut runner = Runner::new(
ch_runner,
SdioBus::new(sdio),
&state.ioctl_state,
&state.net.events,
&state.net.secure_network,
#[cfg(feature = "bluetooth")]
None,
);
runner.init(firmware, nvram, None).await.unwrap();
let control = Control::new(
state_ch,
&state.net.events,
&state.ioctl_state,
&state.net.secure_network,
);
(device, control, runner)
}
/// Create a new instance of the CYW43 driver.
///
/// Returns a handle to the network device, control handle and a runner for driving the low level
/// stack.
#[cfg(feature = "bluetooth")]
pub async fn new_with_bluetooth<'a, PWR, SPI>(
state: &'a mut State,
pwr: PWR,
spi: SPI,
wifi_firmware: &Aligned<A4, [u8]>,
bluetooth_firmware: &Aligned<A4, [u8]>,
nvram: &Aligned<A4, [u8]>,
) -> (
NetDriver<'a>,
bluetooth::BtDriver<'a>,
Control<'a>,
Runner<'a, SpiBus<PWR, SPI>>,
)
where
PWR: OutputPin,
SPI: SpiBusCyw43,
{
let (ch_runner, device) = ch::new(&mut state.net.ch, ch::driver::HardwareAddress::Ethernet([0; 6]));
let state_ch = ch_runner.state_runner();
let (bt_runner, bt_driver) = bluetooth::new(&mut state.bt);
let mut runner = Runner::new(
ch_runner,
SpiBus::new(pwr, spi),
&state.ioctl_state,
&state.net.events,
&state.net.secure_network,
#[cfg(feature = "bluetooth")]
Some(bt_runner),
);
runner
.init(wifi_firmware, nvram, Some(bluetooth_firmware))
.await
.unwrap();
let control = Control::new(
state_ch,
&state.net.events,
&state.ioctl_state,
&state.net.secure_network,
);
(device, bt_driver, control, runner)
}
/// Include bytes aligned to A4 in the binary
#[macro_export]
macro_rules! aligned_bytes {
($path:expr) => {{
{
static BYTES: &cyw43::Aligned<cyw43::A4, [u8]> = &cyw43::Aligned(*include_bytes!($path));
BYTES
}
}};
}
================================================
FILE: cyw43/src/runner.rs
================================================
use core::sync::atomic::AtomicBool;
use core::sync::atomic::Ordering::Relaxed;
use aligned::{A4, Aligned};
use embassy_futures::select::{Either4, select4};
use embassy_net_driver_channel as ch;
use embassy_net_driver_channel::driver::LinkState;
use embassy_time::{Duration, Timer, block_for};
use crate::consts::*;
use crate::events::{Event, Events, Status};
use crate::fmt::Bytes;
use crate::ioctl::{IoctlState, IoctlType, PendingIoctl};
pub use crate::spi::SpiBusCyw43;
use crate::structs::*;
use crate::util::{aligned_mut, aligned_ref, slice8_mut, slice16_mut, try_until};
use crate::{CHIP, Core, MTU, events};
#[cfg(feature = "firmware-logs")]
struct LogState {
addr: u32,
last_idx: usize,
buf: [u8; 256],
buf_count: usize,
}
#[cfg(feature = "firmware-logs")]
impl Default for LogState {
fn default() -> Self {
Self {
addr: Default::default(),
last_idx: Default::default(),
buf: [0; 256],
buf_count: Default::default(),
}
}
}
pub(crate) enum BusType {
Spi,
Sdio,
}
pub(crate) trait SealedBus {
const TYPE: BusType;
async fn init(&mut self, bluetooth_enabled: bool);
async fn wlan_read(&mut self, buf: &mut Aligned<A4, [u8]>);
async fn wlan_write(&mut self, buf: &Aligned<A4, [u8]>);
#[allow(unused)]
async fn bp_read(&mut self, addr: u32, data: &mut [u8]);
async fn bp_write(&mut self, addr: u32, data: &[u8]);
async fn bp_read8(&mut self, addr: u32) -> u8;
async fn bp_write8(&mut self, addr: u32, val: u8);
async fn bp_read16(&mut self, addr: u32) -> u16;
#[allow(unused)]
async fn bp_write16(&mut self, addr: u32, val: u16);
#[allow(unused)]
async fn bp_read32(&mut self, addr: u32) -> u32;
async fn bp_write32(&mut self, addr: u32, val: u32);
async fn read8(&mut self, func: u32, addr: u32) -> u8;
async fn write8(&mut self, func: u32, addr: u32, val: u8);
async fn read16(&mut self, func: u32, addr: u32) -> u16;
async fn write16(&mut self, func: u32, addr: u32, val: u16);
async fn read32(&mut self, func: u32, addr: u32) -> u32;
#[allow(unused)]
async fn write32(&mut self, func: u32, addr: u32, val: u32);
gitextract_vlawd1i1/
├── .gitattributes
├── .github/
│ ├── ci/
│ │ ├── book.sh
│ │ ├── build-nightly.sh
│ │ ├── build-xtensa.sh
│ │ ├── build.sh
│ │ ├── doc.sh
│ │ ├── janitor.sh
│ │ ├── rustfmt.sh
│ │ ├── test-nightly.sh
│ │ └── test.sh
│ └── workflows/
│ ├── matrix-bot-issues.yml
│ └── matrix-bot.yml
├── .gitignore
├── .helix/
│ └── languages.toml
├── .vscode/
│ ├── .gitignore
│ ├── extensions.json
│ └── settings.json
├── LICENSE-APACHE
├── LICENSE-CC-BY-SA
├── LICENSE-MIT
├── NOTICE.md
├── README.md
├── RELEASE.md
├── ci-nightly.sh
├── ci-xtensa.sh
├── ci.sh
├── cyw43/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── bluetooth.rs
│ ├── consts.rs
│ ├── control.rs
│ ├── countries.rs
│ ├── events.rs
│ ├── fmt.rs
│ ├── ioctl.rs
│ ├── lib.rs
│ ├── runner.rs
│ ├── sdio.rs
│ ├── spi.rs
│ ├── structs.rs
│ └── util.rs
├── cyw43-firmware/
│ ├── .gitignore
│ ├── LICENSE-permissive-binary-license-1.0.txt
│ ├── README.md
│ └── write_nvrams.rs
├── cyw43-pio/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── docs/
│ ├── Makefile
│ ├── README.md
│ ├── examples/
│ │ ├── basic/
│ │ │ ├── .cargo/
│ │ │ │ └── config.toml
│ │ │ ├── Cargo.toml
│ │ │ ├── build.rs
│ │ │ ├── memory.x
│ │ │ └── src/
│ │ │ └── main.rs
│ │ └── layer-by-layer/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── blinky-async/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── blinky-hal/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── blinky-irq/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── blinky-pac/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ └── memory.x
│ ├── images/
│ │ ├── embassy_executor.drawio
│ │ └── embassy_irq.drawio
│ ├── index.adoc
│ └── pages/
│ ├── basic_application.adoc
│ ├── beginners.adoc
│ ├── best_practices.adoc
│ ├── bootloader.adoc
│ ├── developer.adoc
│ ├── developer_stm32.adoc
│ ├── embassy_in_the_wild.adoc
│ ├── examples.adoc
│ ├── faq.adoc
│ ├── getting_started.adoc
│ ├── hal.adoc
│ ├── imxrt.adoc
│ ├── layer_by_layer.adoc
│ ├── mcxa.adoc
│ ├── microchip.adoc
│ ├── new_project.adoc
│ ├── nrf.adoc
│ ├── overview.adoc
│ ├── project_structure.adoc
│ ├── runtime.adoc
│ ├── sharing_peripherals.adoc
│ ├── stm32.adoc
│ ├── system.adoc
│ └── time_keeping.adoc
├── embassy-boot/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── boot_loader.rs
│ ├── digest_adapters/
│ │ ├── ed25519_dalek.rs
│ │ ├── mod.rs
│ │ └── salty.rs
│ ├── firmware_updater/
│ │ ├── asynch.rs
│ │ ├── blocking.rs
│ │ └── mod.rs
│ ├── fmt.rs
│ ├── lib.rs
│ ├── mem_flash.rs
│ └── test_flash/
│ ├── asynch.rs
│ ├── blocking.rs
│ └── mod.rs
├── embassy-boot-nrf/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── fmt.rs
│ └── lib.rs
├── embassy-boot-rp/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ └── src/
│ ├── fmt.rs
│ └── lib.rs
├── embassy-boot-stm32/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ └── src/
│ ├── fmt.rs
│ └── lib.rs
├── embassy-embedded-hal/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── adapter/
│ │ ├── blocking_async.rs
│ │ ├── mod.rs
│ │ └── yielding_async.rs
│ ├── flash/
│ │ ├── concat_flash.rs
│ │ ├── mem_flash.rs
│ │ ├── mod.rs
│ │ └── partition/
│ │ ├── asynch.rs
│ │ ├── blocking.rs
│ │ └── mod.rs
│ ├── lib.rs
│ └── shared_bus/
│ ├── asynch/
│ │ ├── i2c.rs
│ │ ├── mod.rs
│ │ └── spi.rs
│ ├── blocking/
│ │ ├── i2c.rs
│ │ ├── mod.rs
│ │ └── spi.rs
│ └── mod.rs
├── embassy-executor/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── build_common.rs
│ ├── gen_config.py
│ ├── src/
│ │ ├── fmt.rs
│ │ ├── lib.rs
│ │ ├── metadata.rs
│ │ ├── platform/
│ │ │ ├── avr.rs
│ │ │ ├── cortex_ar.rs
│ │ │ ├── cortex_m.rs
│ │ │ ├── riscv32.rs
│ │ │ ├── spin.rs
│ │ │ ├── std.rs
│ │ │ └── wasm.rs
│ │ ├── raw/
│ │ │ ├── deadline.rs
│ │ │ ├── mod.rs
│ │ │ ├── run_queue.rs
│ │ │ ├── state_atomics.rs
│ │ │ ├── state_atomics_arm.rs
│ │ │ ├── state_critical_section.rs
│ │ │ ├── trace.rs
│ │ │ ├── util.rs
│ │ │ ├── waker.rs
│ │ │ └── waker_turbo.rs
│ │ └── spawner.rs
│ └── tests/
│ ├── test.rs
│ ├── ui/
│ │ ├── abi.rs
│ │ ├── abi.stderr
│ │ ├── bad_return.rs
│ │ ├── bad_return.stderr
│ │ ├── bad_return_impl_future.rs
│ │ ├── bad_return_impl_future.stderr
│ │ ├── bad_return_impl_future_nightly.rs
│ │ ├── bad_return_impl_future_nightly.stderr
│ │ ├── generics.rs
│ │ ├── generics.stderr
│ │ ├── impl_trait.rs
│ │ ├── impl_trait.stderr
│ │ ├── impl_trait_nested.rs
│ │ ├── impl_trait_nested.stderr
│ │ ├── impl_trait_static.rs
│ │ ├── impl_trait_static.stderr
│ │ ├── nonstatic_ref_anon.rs
│ │ ├── nonstatic_ref_anon.stderr
│ │ ├── nonstatic_ref_anon_nested.rs
│ │ ├── nonstatic_ref_anon_nested.stderr
│ │ ├── nonstatic_ref_elided.rs
│ │ ├── nonstatic_ref_elided.stderr
│ │ ├── nonstatic_ref_generic.rs
│ │ ├── nonstatic_ref_generic.stderr
│ │ ├── nonstatic_struct_anon.rs
│ │ ├── nonstatic_struct_anon.stderr
│ │ ├── nonstatic_struct_elided.rs
│ │ ├── nonstatic_struct_elided.stderr
│ │ ├── nonstatic_struct_generic.rs
│ │ ├── nonstatic_struct_generic.stderr
│ │ ├── not_async.rs
│ │ ├── not_async.stderr
│ │ ├── return_impl_future_nonsend.rs
│ │ ├── return_impl_future_nonsend.stderr
│ │ ├── return_impl_send.rs
│ │ ├── return_impl_send.stderr
│ │ ├── return_impl_send_nightly.rs
│ │ ├── return_impl_send_nightly.stderr
│ │ ├── self.rs
│ │ ├── self.stderr
│ │ ├── self_ref.rs
│ │ ├── self_ref.stderr
│ │ ├── spawn_nonsend.rs
│ │ ├── spawn_nonsend.stderr
│ │ ├── task_safety_attribute.rs
│ │ ├── type_error.rs
│ │ ├── type_error.stderr
│ │ ├── unsafe_op_in_unsafe_task.rs
│ │ ├── unsafe_op_in_unsafe_task.stderr
│ │ ├── where_clause.rs
│ │ └── where_clause.stderr
│ └── ui.rs
├── embassy-executor-macros/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── lib.rs
│ ├── macros/
│ │ ├── main.rs
│ │ ├── mod.rs
│ │ └── task.rs
│ └── util.rs
├── embassy-executor-timer-queue/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── embassy-futures/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── block_on.rs
│ ├── fmt.rs
│ ├── join.rs
│ ├── lib.rs
│ ├── select.rs
│ └── yield_now.rs
├── embassy-hal-internal/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── build_common.rs
│ └── src/
│ ├── atomic_ring_buffer.rs
│ ├── drop.rs
│ ├── fmt.rs
│ ├── interrupt.rs
│ ├── lib.rs
│ ├── macros.rs
│ ├── peripheral.rs
│ └── ratio.rs
├── embassy-imxrt/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── chips/
│ │ ├── mimxrt633s.rs
│ │ └── mimxrt685s.rs
│ ├── clocks.rs
│ ├── crc.rs
│ ├── dma.rs
│ ├── flexcomm/
│ │ ├── mod.rs
│ │ ├── spi.rs
│ │ └── uart.rs
│ ├── fmt.rs
│ ├── gpio.rs
│ ├── iopctl.rs
│ ├── lib.rs
│ ├── rng.rs
│ └── time_driver.rs
├── embassy-mcxa/
│ ├── .gitignore
│ ├── Cargo.toml
│ ├── DEVGUIDE.md
│ ├── README.md
│ └── src/
│ ├── adc.rs
│ ├── cdog.rs
│ ├── chips/
│ │ ├── mcxa2xx.rs
│ │ ├── mcxa5xx.rs
│ │ └── mod.rs
│ ├── clkout.rs
│ ├── clocks/
│ │ ├── config.rs
│ │ ├── gate.rs
│ │ ├── mod.rs
│ │ ├── operator.rs
│ │ ├── periph_helpers/
│ │ │ ├── mcxa2xx.rs
│ │ │ ├── mcxa5xx.rs
│ │ │ └── mod.rs
│ │ ├── sleep.rs
│ │ └── types.rs
│ ├── config.rs
│ ├── crc.rs
│ ├── ctimer/
│ │ ├── capture.rs
│ │ ├── mod.rs
│ │ └── pwm.rs
│ ├── dma.rs
│ ├── executor.rs
│ ├── flash.rs
│ ├── gpio.rs
│ ├── i2c/
│ │ ├── controller.rs
│ │ ├── mod.rs
│ │ └── target.rs
│ ├── i3c/
│ │ ├── controller.rs
│ │ └── mod.rs
│ ├── inputmux.rs
│ ├── lib.rs
│ ├── lpuart/
│ │ ├── bbq.rs
│ │ ├── blocking.rs
│ │ ├── buffered.rs
│ │ ├── dma.rs
│ │ └── mod.rs
│ ├── ostimer.rs
│ ├── perf_counters.rs
│ ├── reset_reason.rs
│ ├── rtc/
│ │ ├── mcxa2xx.rs
│ │ ├── mcxa5xx.rs
│ │ └── mod.rs
│ ├── spi/
│ │ ├── controller.rs
│ │ └── mod.rs
│ ├── trng.rs
│ └── wwdt.rs
├── embassy-microchip/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── fmt.rs
│ ├── gpio.rs
│ ├── i2c.rs
│ ├── lib.rs
│ ├── pwm.rs
│ ├── tach.rs
│ ├── time_driver.rs
│ └── uart.rs
├── embassy-mspm0/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── build_common.rs
│ └── src/
│ ├── adc.rs
│ ├── dma.rs
│ ├── fmt.rs
│ ├── gpio.rs
│ ├── i2c.rs
│ ├── i2c_target.rs
│ ├── lib.rs
│ ├── macros.rs
│ ├── mathacl.rs
│ ├── time_driver.rs
│ ├── timer.rs
│ ├── trng.rs
│ ├── uart/
│ │ ├── buffered.rs
│ │ └── mod.rs
│ └── wwdt.rs
├── embassy-net/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── dns.rs
│ ├── driver_util.rs
│ ├── fmt.rs
│ ├── icmp.rs
│ ├── lib.rs
│ ├── raw.rs
│ ├── tcp.rs
│ ├── time.rs
│ └── udp.rs
├── embassy-net-adin1110/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── crc32.rs
│ ├── crc8.rs
│ ├── fmt.rs
│ ├── lib.rs
│ ├── mdio.rs
│ ├── phy.rs
│ └── regs.rs
├── embassy-net-driver/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── embassy-net-driver-channel/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── fmt.rs
│ └── lib.rs
├── embassy-net-enc28j60/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── bank0.rs
│ ├── bank1.rs
│ ├── bank2.rs
│ ├── bank3.rs
│ ├── common.rs
│ ├── fmt.rs
│ ├── header.rs
│ ├── lib.rs
│ ├── macros.rs
│ ├── phy.rs
│ └── traits.rs
├── embassy-net-esp-hosted/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── control.rs
│ ├── esp_hosted_config.proto
│ ├── fmt.rs
│ ├── iface.rs
│ ├── ioctl.rs
│ ├── lib.rs
│ └── proto.rs
├── embassy-net-nrf91/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── context.rs
│ ├── fmt.rs
│ └── lib.rs
├── embassy-net-ppp/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── fmt.rs
│ └── lib.rs
├── embassy-net-tuntap/
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── embassy-net-wiznet/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── chip/
│ │ ├── mod.rs
│ │ ├── w5100s.rs
│ │ ├── w5500.rs
│ │ ├── w6100.rs
│ │ └── w6300.rs
│ ├── device.rs
│ └── lib.rs
├── embassy-nrf/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── buffered_uarte/
│ │ ├── mod.rs
│ │ ├── v1.rs
│ │ └── v2.rs
│ ├── chips/
│ │ ├── nrf51.rs
│ │ ├── nrf52805.rs
│ │ ├── nrf52810.rs
│ │ ├── nrf52811.rs
│ │ ├── nrf52820.rs
│ │ ├── nrf52832.rs
│ │ ├── nrf52833.rs
│ │ ├── nrf52840.rs
│ │ ├── nrf5340_app.rs
│ │ ├── nrf5340_net.rs
│ │ ├── nrf54l05_app.rs
│ │ ├── nrf54l10_app.rs
│ │ ├── nrf54l15_app.rs
│ │ ├── nrf54lm20_app.rs
│ │ ├── nrf9120.rs
│ │ └── nrf9160.rs
│ ├── cracen.rs
│ ├── cryptocell_rng.rs
│ ├── egu.rs
│ ├── embassy_net_802154_driver.rs
│ ├── fmt.rs
│ ├── gpio.rs
│ ├── gpiote.rs
│ ├── i2s.rs
│ ├── ipc.rs
│ ├── lib.rs
│ ├── nfct.rs
│ ├── nvmc.rs
│ ├── pdm.rs
│ ├── power.rs
│ ├── ppi/
│ │ ├── dppi.rs
│ │ ├── mod.rs
│ │ └── ppi.rs
│ ├── pwm.rs
│ ├── qdec.rs
│ ├── qspi.rs
│ ├── radio/
│ │ ├── ieee802154.rs
│ │ └── mod.rs
│ ├── reset.rs
│ ├── rng.rs
│ ├── rramc.rs
│ ├── rtc.rs
│ ├── saadc.rs
│ ├── spim.rs
│ ├── spis.rs
│ ├── temp.rs
│ ├── time_driver.rs
│ ├── timer.rs
│ ├── twim.rs
│ ├── twis.rs
│ ├── uarte.rs
│ ├── usb/
│ │ ├── mod.rs
│ │ └── vbus_detect.rs
│ ├── util.rs
│ └── wdt.rs
├── embassy-nxp/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── build.rs
│ ├── build_common.rs
│ └── src/
│ ├── chips/
│ │ ├── lpc55.rs
│ │ ├── mimxrt1011.rs
│ │ └── mimxrt1062.rs
│ ├── dma/
│ │ └── lpc55.rs
│ ├── dma.rs
│ ├── fmt.rs
│ ├── gpio/
│ │ ├── lpc55.rs
│ │ └── rt1xxx.rs
│ ├── gpio.rs
│ ├── iomuxc.rs
│ ├── lib.rs
│ ├── pint.rs
│ ├── pwm/
│ │ └── lpc55.rs
│ ├── pwm.rs
│ ├── sct.rs
│ ├── time_driver/
│ │ ├── pit.rs
│ │ └── rtc.rs
│ ├── usart/
│ │ └── lpc55.rs
│ └── usart.rs
├── embassy-rp/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── LICENSE-APACHE
│ ├── LICENSE-MIT
│ ├── README.md
│ ├── build.rs
│ ├── funcsel.txt
│ ├── link-rp.x.in
│ └── src/
│ ├── adc.rs
│ ├── aon_timer/
│ │ └── mod.rs
│ ├── block.rs
│ ├── bootsel.rs
│ ├── clocks.rs
│ ├── critical_section_impl.rs
│ ├── datetime/
│ │ ├── datetime_chrono.rs
│ │ ├── datetime_no_deps.rs
│ │ ├── epoch.rs
│ │ └── mod.rs
│ ├── dma.rs
│ ├── executor.rs
│ ├── flash.rs
│ ├── float/
│ │ ├── add_sub.rs
│ │ ├── cmp.rs
│ │ ├── conv.rs
│ │ ├── div.rs
│ │ ├── functions.rs
│ │ ├── mod.rs
│ │ └── mul.rs
│ ├── fmt.rs
│ ├── gpio.rs
│ ├── i2c.rs
│ ├── i2c_slave.rs
│ ├── intrinsics.rs
│ ├── lib.rs
│ ├── multicore.rs
│ ├── otp.rs
│ ├── pio/
│ │ ├── instr.rs
│ │ └── mod.rs
│ ├── pio_programs/
│ │ ├── clk.rs
│ │ ├── clock_divider.rs
│ │ ├── hd44780.rs
│ │ ├── i2s.rs
│ │ ├── mod.rs
│ │ ├── onewire.rs
│ │ ├── pwm.rs
│ │ ├── rotary_encoder.rs
│ │ ├── spi.rs
│ │ ├── stepper.rs
│ │ ├── uart.rs
│ │ └── ws2812.rs
│ ├── psram.rs
│ ├── pwm.rs
│ ├── qmi_cs1.rs
│ ├── relocate.rs
│ ├── reset.rs
│ ├── rom_data/
│ │ ├── mod.rs
│ │ ├── rp2040.rs
│ │ └── rp235x.rs
│ ├── rtc/
│ │ ├── conversions.rs
│ │ ├── filter.rs
│ │ └── mod.rs
│ ├── spi.rs
│ ├── spinlock.rs
│ ├── spinlock_mutex.rs
│ ├── time_driver.rs
│ ├── trng.rs
│ ├── uart/
│ │ ├── buffered.rs
│ │ └── mod.rs
│ ├── usb.rs
│ └── watchdog.rs
├── embassy-stm32/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── build_common.rs
│ └── src/
│ ├── adc/
│ │ ├── adc4.rs
│ │ ├── c0.rs
│ │ ├── f1.rs
│ │ ├── f3.rs
│ │ ├── f3_v1_1.rs
│ │ ├── g4.rs
│ │ ├── injected.rs
│ │ ├── mod.rs
│ │ ├── ringbuffered.rs
│ │ ├── v1.rs
│ │ ├── v2.rs
│ │ ├── v3.rs
│ │ ├── v4.rs
│ │ └── watchdog_v1.rs
│ ├── aes/
│ │ └── mod.rs
│ ├── backup_sram.rs
│ ├── can/
│ │ ├── bxcan/
│ │ │ ├── filter.rs
│ │ │ ├── mod.rs
│ │ │ └── registers.rs
│ │ ├── common.rs
│ │ ├── enums.rs
│ │ ├── fd/
│ │ │ ├── config.rs
│ │ │ ├── filter.rs
│ │ │ ├── message_ram/
│ │ │ │ ├── common.rs
│ │ │ │ ├── enums.rs
│ │ │ │ ├── extended_filter.rs
│ │ │ │ ├── generic.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── rxfifo_element.rs
│ │ │ │ ├── standard_filter.rs
│ │ │ │ ├── txbuffer_element.rs
│ │ │ │ └── txevent_element.rs
│ │ │ ├── mod.rs
│ │ │ └── peripheral.rs
│ │ ├── fdcan.rs
│ │ ├── frame.rs
│ │ ├── mod.rs
│ │ └── util.rs
│ ├── comp.rs
│ ├── cordic/
│ │ ├── enums.rs
│ │ ├── errors.rs
│ │ ├── mod.rs
│ │ └── utils.rs
│ ├── cpu.rs
│ ├── crc/
│ │ ├── mod.rs
│ │ ├── v1.rs
│ │ └── v2v3.rs
│ ├── cryp/
│ │ └── mod.rs
│ ├── dac/
│ │ └── mod.rs
│ ├── dcmi.rs
│ ├── dma/
│ │ ├── dma_bdma.rs
│ │ ├── dmamux.rs
│ │ ├── gpdma/
│ │ │ ├── linked_list.rs
│ │ │ ├── mod.rs
│ │ │ └── ringbuffered.rs
│ │ ├── mod.rs
│ │ ├── ringbuffer/
│ │ │ ├── mod.rs
│ │ │ └── tests/
│ │ │ ├── mod.rs
│ │ │ └── prop_test/
│ │ │ ├── mod.rs
│ │ │ ├── reader.rs
│ │ │ └── writer.rs
│ │ ├── util.rs
│ │ └── word.rs
│ ├── dsihost.rs
│ ├── dts/
│ │ ├── mod.rs
│ │ └── tsel.rs
│ ├── eth/
│ │ ├── generic_phy.rs
│ │ ├── mod.rs
│ │ ├── sma/
│ │ │ ├── mod.rs
│ │ │ ├── v1.rs
│ │ │ └── v2.rs
│ │ ├── v1/
│ │ │ ├── mod.rs
│ │ │ ├── rx_desc.rs
│ │ │ └── tx_desc.rs
│ │ └── v2/
│ │ ├── descriptors.rs
│ │ └── mod.rs
│ ├── executor.rs
│ ├── exti/
│ │ ├── blocking.rs
│ │ ├── low_level.rs
│ │ └── mod.rs
│ ├── flash/
│ │ ├── asynch.rs
│ │ ├── c.rs
│ │ ├── common.rs
│ │ ├── eeprom.rs
│ │ ├── f0.rs
│ │ ├── f1f3.rs
│ │ ├── f2.rs
│ │ ├── f4.rs
│ │ ├── f7.rs
│ │ ├── g.rs
│ │ ├── h5.rs
│ │ ├── h50.rs
│ │ ├── h7.rs
│ │ ├── l.rs
│ │ ├── mod.rs
│ │ ├── other.rs
│ │ ├── u0.rs
│ │ └── u5.rs
│ ├── fmc.rs
│ ├── fmt.rs
│ ├── gpio.rs
│ ├── hash/
│ │ └── mod.rs
│ ├── hrtim/
│ │ ├── bridge_converter.rs
│ │ ├── mod.rs
│ │ ├── resonant_converter.rs
│ │ └── traits.rs
│ ├── hsem/
│ │ └── mod.rs
│ ├── hspi/
│ │ ├── enums.rs
│ │ └── mod.rs
│ ├── i2c/
│ │ ├── config.rs
│ │ ├── mod.rs
│ │ ├── v1.rs
│ │ └── v2.rs
│ ├── i2s.rs
│ ├── ipcc.rs
│ ├── lcd.rs
│ ├── lib.rs
│ ├── low_power.rs
│ ├── lptim/
│ │ ├── channel.rs
│ │ ├── mod.rs
│ │ ├── pwm.rs
│ │ └── timer/
│ │ ├── channel_direction.rs
│ │ ├── mod.rs
│ │ └── prescaler.rs
│ ├── ltdc.rs
│ ├── macros.rs
│ ├── opamp.rs
│ ├── ospi/
│ │ ├── enums.rs
│ │ └── mod.rs
│ ├── pka/
│ │ └── mod.rs
│ ├── qspi/
│ │ ├── enums.rs
│ │ └── mod.rs
│ ├── rcc/
│ │ ├── bd.rs
│ │ ├── c0.rs
│ │ ├── f013.rs
│ │ ├── f247.rs
│ │ ├── g0.rs
│ │ ├── g4.rs
│ │ ├── h.rs
│ │ ├── hsi48.rs
│ │ ├── l.rs
│ │ ├── mco.rs
│ │ ├── mod.rs
│ │ ├── n6.rs
│ │ ├── u3.rs
│ │ ├── u5.rs
│ │ └── wba.rs
│ ├── rng.rs
│ ├── rtc/
│ │ ├── datetime.rs
│ │ ├── low_power.rs
│ │ ├── mod.rs
│ │ ├── v2.rs
│ │ └── v3.rs
│ ├── saes/
│ │ └── mod.rs
│ ├── sai/
│ │ └── mod.rs
│ ├── sdmmc/
│ │ ├── mod.rs
│ │ ├── sd.rs
│ │ └── sdio.rs
│ ├── spdifrx/
│ │ └── mod.rs
│ ├── spi/
│ │ └── mod.rs
│ ├── time.rs
│ ├── time_driver/
│ │ ├── gp16.rs
│ │ ├── lptim.rs
│ │ └── mod.rs
│ ├── timer/
│ │ ├── complementary_pwm.rs
│ │ ├── input_capture.rs
│ │ ├── low_level.rs
│ │ ├── mod.rs
│ │ ├── one_pulse.rs
│ │ ├── pwm_input.rs
│ │ ├── qei.rs
│ │ ├── ringbuffered.rs
│ │ └── simple_pwm.rs
│ ├── tsc/
│ │ ├── acquisition_banks.rs
│ │ ├── config.rs
│ │ ├── errors.rs
│ │ ├── io_pin.rs
│ │ ├── mod.rs
│ │ ├── pin_groups.rs
│ │ ├── tsc.rs
│ │ └── types.rs
│ ├── ucpd.rs
│ ├── uid.rs
│ ├── usart/
│ │ ├── buffered.rs
│ │ ├── mod.rs
│ │ └── ringbuffered.rs
│ ├── usb/
│ │ ├── mod.rs
│ │ ├── otg.rs
│ │ └── usb.rs
│ ├── vrefbuf/
│ │ └── mod.rs
│ ├── wdg/
│ │ └── mod.rs
│ └── xspi/
│ ├── enums.rs
│ └── mod.rs
├── embassy-stm32-wpan/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── src/
│ │ ├── lib.rs
│ │ ├── wb55/
│ │ │ ├── channels.rs
│ │ │ ├── cmd.rs
│ │ │ ├── consts.rs
│ │ │ ├── evt.rs
│ │ │ ├── fmt.rs
│ │ │ ├── fus.rs
│ │ │ ├── lhci.rs
│ │ │ ├── mac/
│ │ │ │ ├── commands.rs
│ │ │ │ ├── consts.rs
│ │ │ │ ├── control.rs
│ │ │ │ ├── driver.rs
│ │ │ │ ├── event.rs
│ │ │ │ ├── indications.rs
│ │ │ │ ├── macros.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── opcodes.rs
│ │ │ │ ├── responses.rs
│ │ │ │ ├── runner.rs
│ │ │ │ └── typedefs.rs
│ │ │ ├── mod.rs
│ │ │ ├── shci.rs
│ │ │ ├── sub/
│ │ │ │ ├── ble.rs
│ │ │ │ ├── mac.rs
│ │ │ │ ├── mm.rs
│ │ │ │ ├── mod.rs
│ │ │ │ └── sys.rs
│ │ │ ├── tables.rs
│ │ │ └── unsafe_linked_list.rs
│ │ └── wba/
│ │ ├── RNG_INTEGRATION.md
│ │ ├── bindings.rs
│ │ ├── ble.rs
│ │ ├── context.rs
│ │ ├── error.rs
│ │ ├── gap/
│ │ │ ├── advertiser.rs
│ │ │ ├── connection.rs
│ │ │ ├── mod.rs
│ │ │ ├── scanner.rs
│ │ │ └── types.rs
│ │ ├── gatt/
│ │ │ ├── events.rs
│ │ │ ├── mod.rs
│ │ │ ├── server.rs
│ │ │ └── types.rs
│ │ ├── hci/
│ │ │ ├── command.rs
│ │ │ ├── event.rs
│ │ │ ├── host_if.rs
│ │ │ ├── mod.rs
│ │ │ └── types.rs
│ │ ├── linklayer_plat.rs
│ │ ├── ll_sys/
│ │ │ ├── ll_sys_cs.rs
│ │ │ ├── ll_sys_dp_slp.rs
│ │ │ ├── ll_sys_intf.rs
│ │ │ ├── ll_sys_startup.rs
│ │ │ ├── ll_version.rs
│ │ │ └── mod.rs
│ │ ├── ll_sys_if.rs
│ │ ├── mac_sys_if.rs
│ │ ├── mod.rs
│ │ ├── power_table.rs
│ │ ├── runner.rs
│ │ ├── security/
│ │ │ └── mod.rs
│ │ └── util_seq.rs
│ ├── tl_mbox.x.in
│ ├── tl_mbox_extended_wb1.x.in
│ └── tl_mbox_extended_wbx5.x.in
├── embassy-sync/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── build_common.rs
│ ├── src/
│ │ ├── blocking_mutex/
│ │ │ ├── mod.rs
│ │ │ └── raw.rs
│ │ ├── channel.rs
│ │ ├── fmt.rs
│ │ ├── lazy_lock.rs
│ │ ├── lib.rs
│ │ ├── mutex.rs
│ │ ├── once_lock.rs
│ │ ├── pipe.rs
│ │ ├── priority_channel.rs
│ │ ├── pubsub/
│ │ │ ├── mod.rs
│ │ │ ├── publisher.rs
│ │ │ └── subscriber.rs
│ │ ├── ring_buffer.rs
│ │ ├── rwlock.rs
│ │ ├── semaphore.rs
│ │ ├── signal.rs
│ │ ├── waitqueue/
│ │ │ ├── atomic_waker.rs
│ │ │ ├── atomic_waker_turbo.rs
│ │ │ ├── mod.rs
│ │ │ ├── multi_waker.rs
│ │ │ └── waker_registration.rs
│ │ ├── watch.rs
│ │ └── zerocopy_channel.rs
│ └── tests/
│ ├── ui/
│ │ └── sync_impl/
│ │ ├── lazy_lock_function.rs
│ │ ├── lazy_lock_function.stderr
│ │ ├── lazy_lock_type.rs
│ │ ├── lazy_lock_type.stderr
│ │ ├── once_lock.rs
│ │ └── once_lock.stderr
│ └── ui.rs
├── embassy-time/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── delay.rs
│ ├── driver_mock.rs
│ ├── driver_std.rs
│ ├── driver_wasm.rs
│ ├── duration.rs
│ ├── fmt.rs
│ ├── instant.rs
│ ├── lib.rs
│ └── timer.rs
├── embassy-time-driver/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── gen_tick.py
│ └── src/
│ ├── lib.rs
│ └── tick.rs
├── embassy-time-queue-utils/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ └── src/
│ ├── lib.rs
│ ├── queue_generic.rs
│ └── queue_integrated.rs
├── embassy-usb/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── gen_config.py
│ └── src/
│ ├── builder.rs
│ ├── class/
│ │ ├── cdc_acm.rs
│ │ ├── cdc_ncm/
│ │ │ ├── embassy_net.rs
│ │ │ └── mod.rs
│ │ ├── cmsis_dap_v2.rs
│ │ ├── dfu/
│ │ │ ├── app_mode.rs
│ │ │ ├── consts.rs
│ │ │ ├── dfu_mode.rs
│ │ │ └── mod.rs
│ │ ├── hid.rs
│ │ ├── midi.rs
│ │ ├── mod.rs
│ │ ├── uac1/
│ │ │ ├── class_codes.rs
│ │ │ ├── mod.rs
│ │ │ ├── speaker.rs
│ │ │ └── terminal_type.rs
│ │ └── web_usb.rs
│ ├── control.rs
│ ├── descriptor.rs
│ ├── descriptor_reader.rs
│ ├── fmt.rs
│ ├── lib.rs
│ ├── msos.rs
│ └── types.rs
├── embassy-usb-dfu/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── src/
│ │ ├── application.rs
│ │ ├── dfu.rs
│ │ ├── fmt.rs
│ │ └── lib.rs
│ └── tests/
│ └── usb_dfu_test.rs
├── embassy-usb-driver/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── embassy-usb-logger/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ └── lib.rs
├── embassy-usb-synopsys-otg/
│ ├── CHANGELOG.md
│ ├── Cargo.toml
│ ├── README.md
│ └── src/
│ ├── fmt.rs
│ ├── lib.rs
│ └── otg_v1.rs
├── examples/
│ ├── .cargo/
│ │ └── config.toml
│ ├── boot/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── application/
│ │ │ ├── nrf/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory-bl-nrf91.x
│ │ │ │ ├── memory-bl.x
│ │ │ │ ├── memory-nrf91.x
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── rp/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── stm32f3/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── stm32f7/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── flash-boot.sh
│ │ │ │ ├── memory-bl.x
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── stm32h7/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── flash-boot.sh
│ │ │ │ ├── memory-bl.x
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── stm32l0/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── stm32l1/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── stm32l4/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory.x
│ │ │ │ └── src/
│ │ │ │ └── bin/
│ │ │ │ ├── a.rs
│ │ │ │ └── b.rs
│ │ │ ├── stm32wb-dfu/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory.x
│ │ │ │ ├── secrets/
│ │ │ │ │ └── key.sec
│ │ │ │ └── src/
│ │ │ │ └── main.rs
│ │ │ ├── stm32wba-dfu/
│ │ │ │ ├── .cargo/
│ │ │ │ │ └── config.toml
│ │ │ │ ├── Cargo.toml
│ │ │ │ ├── README.md
│ │ │ │ ├── build.rs
│ │ │ │ ├── memory.x
│ │ │ │ ├── secrets/
│ │ │ │ │ └── key.sec
│ │ │ │ └── src/
│ │ │ │ └── main.rs
│ │ │ └── stm32wl/
│ │ │ ├── .cargo/
│ │ │ │ └── config.toml
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── build.rs
│ │ │ ├── memory.x
│ │ │ └── src/
│ │ │ └── bin/
│ │ │ ├── a.rs
│ │ │ └── b.rs
│ │ └── bootloader/
│ │ ├── nrf/
│ │ │ ├── .cargo/
│ │ │ │ └── config.toml
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── build.rs
│ │ │ ├── memory-bm.x
│ │ │ ├── memory-s140.x
│ │ │ ├── memory.x
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── rp/
│ │ │ ├── .cargo/
│ │ │ │ └── config.toml
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── build.rs
│ │ │ ├── memory.x
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── stm32/
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── build.rs
│ │ │ ├── memory.x
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── stm32-dual-bank/
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── build.rs
│ │ │ ├── memory.x
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── stm32wb-dfu/
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── build.rs
│ │ │ ├── memory.x
│ │ │ ├── secrets/
│ │ │ │ └── key.pub.short
│ │ │ └── src/
│ │ │ └── main.rs
│ │ └── stm32wba-dfu/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ ├── secrets/
│ │ │ └── key.pub.short
│ │ └── src/
│ │ └── main.rs
│ ├── lpc55s69/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky_embassy_time.rs
│ │ ├── blinky_nop.rs
│ │ ├── button_executor.rs
│ │ ├── pwm.rs
│ │ ├── usart_async.rs
│ │ └── usart_blocking.rs
│ ├── mcxa2xx/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc-async.rs
│ │ ├── adc-blocking.rs
│ │ ├── adc-temperature.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_async.rs
│ │ ├── capture.rs
│ │ ├── cdog.rs
│ │ ├── clkout.rs
│ │ ├── cpu-clocks.rs
│ │ ├── crc.rs
│ │ ├── dma_mem_to_mem.rs
│ │ ├── dma_scatter_gather_builder.rs
│ │ ├── flash_iap.rs
│ │ ├── hello.rs
│ │ ├── i2c-async.rs
│ │ ├── i2c-blocking.rs
│ │ ├── i2c-dma.rs
│ │ ├── i2c-scan-blocking.rs
│ │ ├── i2c-target-async.rs
│ │ ├── i2c-target-blocking.rs
│ │ ├── i2c-target-dma.rs
│ │ ├── i3c-async.rs
│ │ ├── i3c-blocking.rs
│ │ ├── i3c-dma.rs
│ │ ├── lpuart_bbq_rx.rs
│ │ ├── lpuart_bbq_tx.rs
│ │ ├── lpuart_buffered.rs
│ │ ├── lpuart_dma.rs
│ │ ├── lpuart_polling.rs
│ │ ├── lpuart_ring_buffer.rs
│ │ ├── power-deepsleep-big-jump.rs
│ │ ├── power-deepsleep-gating.rs
│ │ ├── power-deepsleep-gpio-int.rs
│ │ ├── power-deepsleep.rs
│ │ ├── power-wfe-gated.rs
│ │ ├── pwm.rs
│ │ ├── reset-reason.rs
│ │ ├── rtc_alarm.rs
│ │ ├── spi-async.rs
│ │ ├── spi-blocking.rs
│ │ ├── spi-dma.rs
│ │ ├── trng.rs
│ │ ├── wwdt_interrupt.rs
│ │ └── wwdt_reset.rs
│ ├── mcxa5xx/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc-async.rs
│ │ ├── adc-blocking.rs
│ │ ├── adc-temperature.rs
│ │ ├── blinky-firc.rs
│ │ ├── blinky-sosc.rs
│ │ ├── blinky-spll.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_async.rs
│ │ ├── capture.rs
│ │ ├── cdog.rs
│ │ ├── clkout.rs
│ │ ├── crc.rs
│ │ ├── dma_mem_to_mem.rs
│ │ ├── dma_scatter_gather_builder.rs
│ │ ├── hello.rs
│ │ ├── i2c-async.rs
│ │ ├── i2c-blocking.rs
│ │ ├── i2c-dma.rs
│ │ ├── i2c-scan-blocking.rs
│ │ ├── i2c-target-async.rs
│ │ ├── i2c-target-blocking.rs
│ │ ├── i2c-target-dma.rs
│ │ ├── i3c-async.rs
│ │ ├── i3c-blocking.rs
│ │ ├── i3c-dma.rs
│ │ ├── lpuart_bbq_rx.rs
│ │ ├── lpuart_bbq_tx.rs
│ │ ├── lpuart_buffered.rs
│ │ ├── lpuart_dma.rs
│ │ ├── lpuart_polling.rs
│ │ ├── lpuart_ring_buffer.rs
│ │ ├── power-deepsleep-big-jump.rs
│ │ ├── power-deepsleep-gating.rs
│ │ ├── power-deepsleep-gpio-int.rs
│ │ ├── power-deepsleep.rs
│ │ ├── power-wfe-gated.rs
│ │ ├── pwm.rs
│ │ ├── reset-reason.rs
│ │ ├── rtc-alarm.rs
│ │ ├── spi-async.rs
│ │ ├── spi-blocking.rs
│ │ ├── spi-dma.rs
│ │ ├── trng.rs
│ │ ├── wwdt_interrupt.rs
│ │ └── wwdt_reset.rs
│ ├── microchip/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── link_ram.x
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button-async.rs
│ │ ├── button.rs
│ │ ├── i2c-async.rs
│ │ ├── i2c.rs
│ │ ├── pwm.rs
│ │ ├── uart_async.rs
│ │ └── uart_blocking.rs
│ ├── mimxrt1011/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ ├── bin/
│ │ │ ├── blinky.rs
│ │ │ └── button.rs
│ │ └── lib.rs
│ ├── mimxrt1062-evk/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ ├── bin/
│ │ │ ├── blinky.rs
│ │ │ └── button.rs
│ │ └── lib.rs
│ ├── mimxrt6/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── .gitignore
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ ├── bin/
│ │ │ ├── blinky.rs
│ │ │ ├── button.rs
│ │ │ ├── crc.rs
│ │ │ ├── dma.rs
│ │ │ ├── hello.rs
│ │ │ ├── rng.rs
│ │ │ ├── spi-async.rs
│ │ │ ├── spi.rs
│ │ │ ├── uart-async.rs
│ │ │ └── uart.rs
│ │ └── lib.rs
│ ├── mspm0c1104/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── uart.rs
│ │ └── wwdt.rs
│ ├── mspm0g3507/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── i2c.rs
│ │ ├── i2c_async.rs
│ │ ├── i2c_target.rs
│ │ ├── mathacl_ops.rs
│ │ ├── uart.rs
│ │ ├── uart_buffered.rs
│ │ └── wwdt.rs
│ ├── mspm0g3519/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── uart.rs
│ │ └── wwdt.rs
│ ├── mspm0g5187/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ └── wwdt.rs
│ ├── mspm0l1306/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── i2c.rs
│ │ ├── i2c_async.rs
│ │ ├── i2c_target.rs
│ │ ├── uart.rs
│ │ └── wwdt.rs
│ ├── mspm0l2228/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── trng.rs
│ │ ├── uart.rs
│ │ └── wwdt.rs
│ ├── nrf-rtos-trace/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── rtos_trace.rs
│ ├── nrf51/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── blinky.rs
│ ├── nrf52810/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── saadc_lowpower.rs
│ ├── nrf52840/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── buffered_uart.rs
│ │ ├── channel.rs
│ │ ├── channel_sender_receiver.rs
│ │ ├── egu.rs
│ │ ├── ethernet_enc28j60.rs
│ │ ├── executor_fairness_test.rs
│ │ ├── gpiote_channel.rs
│ │ ├── gpiote_port.rs
│ │ ├── i2s_effect.rs
│ │ ├── i2s_monitor.rs
│ │ ├── i2s_waveform.rs
│ │ ├── ieee802154_receive.rs
│ │ ├── ieee802154_send.rs
│ │ ├── manually_create_executor.rs
│ │ ├── multiprio.rs
│ │ ├── mutex.rs
│ │ ├── nfct.rs
│ │ ├── nvmc.rs
│ │ ├── pdm.rs
│ │ ├── pdm_continuous.rs
│ │ ├── ppi.rs
│ │ ├── pubsub.rs
│ │ ├── pwm.rs
│ │ ├── pwm_double_sequence.rs
│ │ ├── pwm_sequence.rs
│ │ ├── pwm_sequence_ppi.rs
│ │ ├── pwm_sequence_ws2812b.rs
│ │ ├── pwm_servo.rs
│ │ ├── qdec.rs
│ │ ├── qspi.rs
│ │ ├── qspi_lowpower.rs
│ │ ├── raw_spawn.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── saadc.rs
│ │ ├── saadc_continuous.rs
│ │ ├── self_spawn.rs
│ │ ├── self_spawn_current_executor.rs
│ │ ├── sixlowpan.rs
│ │ ├── spim.rs
│ │ ├── spis.rs
│ │ ├── temp.rs
│ │ ├── timer.rs
│ │ ├── twim.rs
│ │ ├── twim_lowpower.rs
│ │ ├── twis.rs
│ │ ├── uart.rs
│ │ ├── uart_idle.rs
│ │ ├── uart_split.rs
│ │ ├── usb_ethernet.rs
│ │ ├── usb_hid_keyboard.rs
│ │ ├── usb_hid_mouse.rs
│ │ ├── usb_serial.rs
│ │ ├── usb_serial_multitask.rs
│ │ ├── usb_serial_winusb.rs
│ │ ├── wdt.rs
│ │ └── wifi_esp_hosted.rs
│ ├── nrf52840-edf/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── basic.rs
│ ├── nrf52840-rtic/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── blinky.rs
│ ├── nrf5340/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── cryptocell_rng.rs
│ │ ├── gpiote_channel.rs
│ │ ├── nrf5340dk_internal_caps.rs
│ │ └── uart.rs
│ ├── nrf54l15/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── buffered_uart.rs
│ │ ├── gpiote_channel.rs
│ │ ├── gpiote_port.rs
│ │ ├── pwm.rs
│ │ ├── rng.rs
│ │ ├── rramc.rs
│ │ ├── rramc_buffered.rs
│ │ ├── saadc.rs
│ │ ├── spim.rs
│ │ ├── temp.rs
│ │ ├── timer.rs
│ │ ├── twim.rs
│ │ ├── twis.rs
│ │ ├── uart.rs
│ │ └── wdt.rs
│ ├── nrf54lm20/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── gpio.rs
│ │ ├── gpiote_channel.rs
│ │ ├── gpiote_port.rs
│ │ └── timer.rs
│ ├── nrf9151/
│ │ ├── ns/
│ │ │ ├── .cargo/
│ │ │ │ └── config.toml
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── build.rs
│ │ │ ├── flash_tfm.sh
│ │ │ ├── memory.x
│ │ │ ├── src/
│ │ │ │ └── bin/
│ │ │ │ ├── blinky.rs
│ │ │ │ └── uart.rs
│ │ │ └── tfm.hex
│ │ └── s/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── cryptocell_rng.rs
│ ├── nrf9160/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── modem_tcp_client.rs
│ ├── rp/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── assets/
│ │ │ └── ferris.raw
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_dma.rs
│ │ ├── assign_resources.rs
│ │ ├── blinky.rs
│ │ ├── blinky_two_channels.rs
│ │ ├── blinky_two_tasks.rs
│ │ ├── button.rs
│ │ ├── debounce.rs
│ │ ├── ethernet_w5500_icmp.rs
│ │ ├── ethernet_w5500_icmp_ping.rs
│ │ ├── ethernet_w5500_multisocket.rs
│ │ ├── ethernet_w5500_tcp_client.rs
│ │ ├── ethernet_w5500_tcp_server.rs
│ │ ├── ethernet_w5500_udp.rs
│ │ ├── ethernet_w55rp20_tcp_server.rs
│ │ ├── flash.rs
│ │ ├── gpio_async.rs
│ │ ├── gpout.rs
│ │ ├── i2c_async.rs
│ │ ├── i2c_async_embassy.rs
│ │ ├── i2c_blocking.rs
│ │ ├── i2c_slave.rs
│ │ ├── interrupt.rs
│ │ ├── multicore.rs
│ │ ├── multiprio.rs
│ │ ├── orchestrate_tasks.rs
│ │ ├── overclock.rs
│ │ ├── overclock_manual.rs
│ │ ├── pio_async.rs
│ │ ├── pio_clk.rs
│ │ ├── pio_dma.rs
│ │ ├── pio_hd44780.rs
│ │ ├── pio_i2s.rs
│ │ ├── pio_i2s_mclk.rs
│ │ ├── pio_onewire.rs
│ │ ├── pio_onewire_parasite.rs
│ │ ├── pio_pwm.rs
│ │ ├── pio_rotary_encoder.rs
│ │ ├── pio_servo.rs
│ │ ├── pio_spi.rs
│ │ ├── pio_spi_async.rs
│ │ ├── pio_stepper.rs
│ │ ├── pio_uart.rs
│ │ ├── pio_ws2812.rs
│ │ ├── pwm.rs
│ │ ├── pwm_input.rs
│ │ ├── rosc.rs
│ │ ├── rtc.rs
│ │ ├── rtc_alarm.rs
│ │ ├── shared_bus.rs
│ │ ├── sharing.rs
│ │ ├── spi.rs
│ │ ├── spi_async.rs
│ │ ├── spi_display.rs
│ │ ├── spi_gc9a01.rs
│ │ ├── spi_sdmmc.rs
│ │ ├── uart.rs
│ │ ├── uart_buffered_split.rs
│ │ ├── uart_r503.rs
│ │ ├── uart_unidir.rs
│ │ ├── usb_ethernet.rs
│ │ ├── usb_hid_keyboard.rs
│ │ ├── usb_hid_mouse.rs
│ │ ├── usb_logger.rs
│ │ ├── usb_midi.rs
│ │ ├── usb_raw.rs
│ │ ├── usb_raw_bulk.rs
│ │ ├── usb_serial.rs
│ │ ├── usb_serial_with_handler.rs
│ │ ├── usb_serial_with_logger.rs
│ │ ├── usb_webusb.rs
│ │ ├── watchdog.rs
│ │ ├── wifi_ap_tcp_server.rs
│ │ ├── wifi_blinky.rs
│ │ ├── wifi_scan.rs
│ │ ├── wifi_tcp_server.rs
│ │ ├── wifi_webrequest.rs
│ │ └── zerocopy.rs
│ ├── rp235x/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── assets/
│ │ │ └── ferris.raw
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_dma.rs
│ │ ├── aon_timer_async.rs
│ │ ├── assign_resources.rs
│ │ ├── blinky.rs
│ │ ├── blinky_two_channels.rs
│ │ ├── blinky_two_tasks.rs
│ │ ├── blinky_wifi.rs
│ │ ├── blinky_wifi_pico_plus_2.rs
│ │ ├── button.rs
│ │ ├── debounce.rs
│ │ ├── ethernet_w5500_icmp.rs
│ │ ├── ethernet_w5500_icmp_ping.rs
│ │ ├── ethernet_w5500_multisocket.rs
│ │ ├── ethernet_w5500_tcp_client.rs
│ │ ├── ethernet_w5500_tcp_server.rs
│ │ ├── ethernet_w5500_udp.rs
│ │ ├── ethernet_w6300_udp.rs
│ │ ├── flash.rs
│ │ ├── gpio_async.rs
│ │ ├── gpout.rs
│ │ ├── i2c_async.rs
│ │ ├── i2c_async_embassy.rs
│ │ ├── i2c_blocking.rs
│ │ ├── i2c_slave.rs
│ │ ├── interrupt.rs
│ │ ├── multicore.rs
│ │ ├── multicore_stack_overflow.rs
│ │ ├── multiprio.rs
│ │ ├── otp.rs
│ │ ├── overclock.rs
│ │ ├── pio_async.rs
│ │ ├── pio_dma.rs
│ │ ├── pio_hd44780.rs
│ │ ├── pio_i2s.rs
│ │ ├── pio_i2s_rx.rs
│ │ ├── pio_onewire.rs
│ │ ├── pio_onewire_parasite.rs
│ │ ├── pio_pwm.rs
│ │ ├── pio_rotary_encoder.rs
│ │ ├── pio_rotary_encoder_rxf.rs
│ │ ├── pio_servo.rs
│ │ ├── pio_stepper.rs
│ │ ├── pio_uart.rs
│ │ ├── pio_ws2812.rs
│ │ ├── psram.rs
│ │ ├── pwm.rs
│ │ ├── pwm_input.rs
│ │ ├── pwm_tb6612fng_motor_driver.rs
│ │ ├── rosc.rs
│ │ ├── shared_bus.rs
│ │ ├── sharing.rs
│ │ ├── spi.rs
│ │ ├── spi_async.rs
│ │ ├── spi_display.rs
│ │ ├── spi_sdmmc.rs
│ │ ├── trng.rs
│ │ ├── uart.rs
│ │ ├── uart_buffered_split.rs
│ │ ├── uart_r503.rs
│ │ ├── uart_unidir.rs
│ │ ├── usb_hid_keyboard.rs
│ │ ├── usb_webusb.rs
│ │ ├── watchdog.rs
│ │ └── zerocopy.rs
│ ├── std/
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── src/
│ │ │ ├── bin/
│ │ │ │ ├── net.rs
│ │ │ │ ├── net_dns.rs
│ │ │ │ ├── net_ppp.rs
│ │ │ │ ├── net_udp.rs
│ │ │ │ ├── serial.rs
│ │ │ │ ├── tcp_accept.rs
│ │ │ │ ├── tick.rs
│ │ │ │ └── tick_cancel.rs
│ │ │ └── serial_port.rs
│ │ └── tap.sh
│ ├── stm32c0/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_ring_buffered_timer.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ └── rtc.rs
│ ├── stm32f0/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc-watchdog.rs
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── button_controlled_blink.rs
│ │ ├── button_exti.rs
│ │ ├── hello.rs
│ │ ├── i2c_master.rs
│ │ ├── i2c_slave_async.rs
│ │ ├── i2c_slave_blocking.rs
│ │ ├── multiprio.rs
│ │ └── wdg.rs
│ ├── stm32f072/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── i2c_loopback_test_async.rs
│ ├── stm32f1/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── can.rs
│ │ ├── hello.rs
│ │ ├── input_capture.rs
│ │ ├── pwm_input.rs
│ │ └── usb_serial.rs
│ ├── stm32f105/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── usb_serial.rs
│ ├── stm32f107/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── eth.rs
│ ├── stm32f2/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── pll.rs
│ ├── stm32f3/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_events.rs
│ │ ├── button_exti.rs
│ │ ├── flash.rs
│ │ ├── hello.rs
│ │ ├── multiprio.rs
│ │ ├── spi_dma.rs
│ │ ├── tsc_blocking.rs
│ │ ├── tsc_multipin.rs
│ │ ├── usart_dma.rs
│ │ └── usb_serial.rs
│ ├── stm32f334/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── button.rs
│ │ ├── hello.rs
│ │ ├── hrtim.rs
│ │ ├── opamp.rs
│ │ └── pwm.rs
│ ├── stm32f4/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_dma.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── can.rs
│ │ ├── dac.rs
│ │ ├── eth.rs
│ │ ├── eth_compliance_test.rs
│ │ ├── eth_w5500.rs
│ │ ├── flash.rs
│ │ ├── flash_async.rs
│ │ ├── hello.rs
│ │ ├── i2c.rs
│ │ ├── i2c_async.rs
│ │ ├── i2c_comparison.rs
│ │ ├── i2c_master_test_blocking.rs
│ │ ├── i2c_slave_async.rs
│ │ ├── i2c_slave_blocking.rs
│ │ ├── i2s_dma.rs
│ │ ├── input_capture.rs
│ │ ├── mco.rs
│ │ ├── multiprio.rs
│ │ ├── pwm.rs
│ │ ├── pwm_complementary.rs
│ │ ├── pwm_input.rs
│ │ ├── rtc.rs
│ │ ├── sdmmc.rs
│ │ ├── spi.rs
│ │ ├── spi_dma.rs
│ │ ├── usart.rs
│ │ ├── usart_buffered.rs
│ │ ├── usart_dma.rs
│ │ ├── usb_ethernet.rs
│ │ ├── usb_hid_keyboard.rs
│ │ ├── usb_hid_mouse.rs
│ │ ├── usb_raw.rs
│ │ ├── usb_serial.rs
│ │ ├── usb_uac_speaker.rs
│ │ ├── wdt.rs
│ │ ├── ws2812_pwm.rs
│ │ └── ws2812_spi.rs
│ ├── stm32f401/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── i2c_loopback_test_async.rs
│ ├── stm32f469/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── dsi_bsp.rs
│ ├── stm32f7/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── can.rs
│ │ ├── cryp.rs
│ │ ├── eth.rs
│ │ ├── flash.rs
│ │ ├── hash.rs
│ │ ├── hello.rs
│ │ ├── pwm.rs
│ │ ├── pwm_ringbuffer.rs
│ │ ├── qspi.rs
│ │ ├── sdmmc.rs
│ │ ├── usart_dma.rs
│ │ └── usb_serial.rs
│ ├── stm32g0/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_dma.rs
│ │ ├── adc_oversampling.rs
│ │ ├── adc_ring_buffered_timer.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── flash.rs
│ │ ├── flash_async.rs
│ │ ├── hf_timer.rs
│ │ ├── i2c_async.rs
│ │ ├── input_capture.rs
│ │ ├── onewire_ds18b20.rs
│ │ ├── pwm_complementary.rs
│ │ ├── pwm_input.rs
│ │ ├── rtc.rs
│ │ ├── spi_neopixel.rs
│ │ ├── usart.rs
│ │ ├── usart_buffered.rs
│ │ ├── usart_dma.rs
│ │ └── usb_serial.rs
│ ├── stm32g4/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_differential.rs
│ │ ├── adc_dma.rs
│ │ ├── adc_injected_and_regular.rs
│ │ ├── adc_oversampling.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── can.rs
│ │ ├── i2c_slave.rs
│ │ ├── i2s.rs
│ │ ├── pll.rs
│ │ ├── pwm.rs
│ │ ├── usb_c_pd.rs
│ │ └── usb_serial.rs
│ ├── stm32g474/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── comp.rs
│ │ ├── flash_async.rs
│ │ ├── hrtim.rs
│ │ ├── hrtim_master.rs
│ │ └── pwm_input_async.rs
│ ├── stm32h5/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_dma.rs
│ │ ├── backup_sram.rs
│ │ ├── blinky.rs
│ │ ├── button_exti.rs
│ │ ├── can.rs
│ │ ├── cordic.rs
│ │ ├── dts.rs
│ │ ├── eth.rs
│ │ ├── i2c.rs
│ │ ├── mco.rs
│ │ ├── rng.rs
│ │ ├── sai.rs
│ │ ├── usart.rs
│ │ ├── usart_dma.rs
│ │ ├── usart_split.rs
│ │ ├── usb_c_pd.rs
│ │ ├── usb_serial.rs
│ │ ├── usb_uac_speaker.rs
│ │ └── wifi_scan.rs
│ ├── stm32h7/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_dma.rs
│ │ ├── blinky.rs
│ │ ├── button_exti.rs
│ │ ├── camera.rs
│ │ ├── can.rs
│ │ ├── dac.rs
│ │ ├── dac_dma.rs
│ │ ├── eth.rs
│ │ ├── eth_client.rs
│ │ ├── eth_client_mii.rs
│ │ ├── flash.rs
│ │ ├── flash_async.rs
│ │ ├── fmc.rs
│ │ ├── i2c.rs
│ │ ├── i2c_shared.rs
│ │ ├── low_level_timer_api.rs
│ │ ├── mco.rs
│ │ ├── multiprio.rs
│ │ ├── pwm.rs
│ │ ├── qspi_mdma.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── sai.rs
│ │ ├── sdmmc.rs
│ │ ├── signal.rs
│ │ ├── spi.rs
│ │ ├── spi_bdma.rs
│ │ ├── spi_dma.rs
│ │ ├── usart.rs
│ │ ├── usart_dma.rs
│ │ ├── usart_split.rs
│ │ ├── usb_serial.rs
│ │ └── wdg.rs
│ ├── stm32h723/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── spdifrx.rs
│ ├── stm32h735/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── ltdc.rs
│ ├── stm32h742/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── qspi.rs
│ ├── stm32h755cm4/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── intercore.rs
│ ├── stm32h755cm7/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── intercore.rs
│ ├── stm32h7b0/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── ospi_memory_mapped.rs
│ ├── stm32h7rs/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button_exti.rs
│ │ ├── can.rs
│ │ ├── eth.rs
│ │ ├── i2c.rs
│ │ ├── mco.rs
│ │ ├── multiprio.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── signal.rs
│ │ ├── spi.rs
│ │ ├── spi_dma.rs
│ │ ├── usart.rs
│ │ ├── usart_dma.rs
│ │ ├── usart_split.rs
│ │ ├── usb_serial.rs
│ │ └── xspi_memory_mapped.rs
│ ├── stm32l0/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── dds.rs
│ │ ├── eeprom.rs
│ │ ├── flash.rs
│ │ ├── raw_spawn.rs
│ │ ├── spi.rs
│ │ ├── tsc_async.rs
│ │ ├── tsc_blocking.rs
│ │ ├── tsc_multipin.rs
│ │ ├── usart_dma.rs
│ │ ├── usart_irq.rs
│ │ └── usb_serial.rs
│ ├── stm32l1/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── eeprom.rs
│ │ ├── flash.rs
│ │ ├── spi.rs
│ │ ├── usart.rs
│ │ └── usb_serial.rs
│ ├── stm32l4/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_dma.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── can.rs
│ │ ├── dac.rs
│ │ ├── dac_dma.rs
│ │ ├── flash_async.rs
│ │ ├── i2c.rs
│ │ ├── i2c_blocking_async.rs
│ │ ├── i2c_dma.rs
│ │ ├── mco.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── spe_adin1110_http_server.rs
│ │ ├── spi.rs
│ │ ├── spi_blocking_async.rs
│ │ ├── spi_dma.rs
│ │ ├── tsc_async.rs
│ │ ├── tsc_blocking.rs
│ │ ├── tsc_multipin.rs
│ │ ├── usart.rs
│ │ ├── usart_dma.rs
│ │ └── usb_serial.rs
│ ├── stm32l4-rtic/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── blinky_timer_interrupt.rs
│ │ └── button_exti.rs
│ ├── stm32l432/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── qspi_mmap.rs
│ ├── stm32l5/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── button_exti.rs
│ │ ├── rng.rs
│ │ ├── usb_ethernet.rs
│ │ ├── usb_hid_mouse.rs
│ │ └── usb_serial.rs
│ ├── stm32l5-lp/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ └── stop.rs
│ ├── stm32n6/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── crc.rs
│ │ ├── hash.rs
│ │ ├── xspi_flash.rs
│ │ └── xspi_psram.rs
│ ├── stm32u0/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── crc.rs
│ │ ├── dac.rs
│ │ ├── flash.rs
│ │ ├── i2c.rs
│ │ ├── lcd.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── spi.rs
│ │ ├── usart.rs
│ │ ├── usb_serial.rs
│ │ └── wdt.rs
│ ├── stm32u3/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button_exti.rs
│ │ ├── mco.rs
│ │ ├── rtc.rs
│ │ └── usb_serial.rs
│ ├── stm32u5/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── boot.rs
│ │ ├── flash.rs
│ │ ├── hspi_memory_mapped.rs
│ │ ├── i2c.rs
│ │ ├── ltdc.rs
│ │ ├── rng.rs
│ │ ├── tsc.rs
│ │ ├── usb_hs_serial.rs
│ │ └── usb_serial.rs
│ ├── stm32wb/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ ├── button_exti.rs
│ │ ├── eddystone_beacon.rs
│ │ ├── fus_update.rs
│ │ ├── gatt_server.rs
│ │ ├── mac_ffd.rs
│ │ ├── mac_ffd_net.rs
│ │ ├── mac_rfd.rs
│ │ ├── tl_mbox.rs
│ │ ├── tl_mbox_ble.rs
│ │ └── tl_mbox_mac.rs
│ ├── stm32wba/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_ring_buffered.rs
│ │ ├── aes_cbc.rs
│ │ ├── aes_ccm.rs
│ │ ├── aes_ctr.rs
│ │ ├── aes_ecb.rs
│ │ ├── aes_gcm.rs
│ │ ├── aes_gmac.rs
│ │ ├── ble_advertiser.rs
│ │ ├── ble_central.rs
│ │ ├── ble_gatt_server.rs
│ │ ├── ble_peripheral_connect.rs
│ │ ├── ble_scanner.rs
│ │ ├── ble_secure.rs
│ │ ├── blinky.rs
│ │ ├── button_exti.rs
│ │ ├── device_info.rs
│ │ ├── flash.rs
│ │ ├── mac_ffd.rs
│ │ ├── pka_ecdh.rs
│ │ ├── pka_ecdsa_sign.rs
│ │ ├── pka_ecdsa_verify.rs
│ │ ├── pka_rsa.rs
│ │ ├── pka_rsa_crt.rs
│ │ ├── pka_rsa_keygen.rs
│ │ ├── pwm.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── saes_ecb.rs
│ │ └── saes_gcm.rs
│ ├── stm32wba-lp/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── button_exti.rs
│ ├── stm32wba6/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README_PCM.md
│ │ ├── build.rs
│ │ ├── convert_wav.py
│ │ ├── convert_wav.sh
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── adc_ring_buffered.rs
│ │ ├── aes_cbc.rs
│ │ ├── aes_ccm.rs
│ │ ├── aes_ctr.rs
│ │ ├── aes_ecb.rs
│ │ ├── aes_gcm.rs
│ │ ├── aes_gmac.rs
│ │ ├── ble_advertiser.rs
│ │ ├── ble_central.rs
│ │ ├── ble_gatt_server.rs
│ │ ├── ble_peripheral_connect.rs
│ │ ├── ble_scanner.rs
│ │ ├── ble_secure.rs
│ │ ├── blinky.rs
│ │ ├── button_exti.rs
│ │ ├── comp.rs
│ │ ├── comp_window.rs
│ │ ├── device_info.rs
│ │ ├── flash.rs
│ │ ├── mac_ffd.rs
│ │ ├── pka_ecdh.rs
│ │ ├── pka_ecdsa_sign.rs
│ │ ├── pka_ecdsa_verify.rs
│ │ ├── pka_rsa.rs
│ │ ├── pka_rsa_crt.rs
│ │ ├── pka_rsa_keygen.rs
│ │ ├── pwm.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── saes_ecb.rs
│ │ ├── saes_gcm.rs
│ │ ├── sdmmc_sai.rs
│ │ ├── usb_hs_serial.rs
│ │ └── wwdg.rs
│ ├── stm32wba6-lp/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── button_exti.rs
│ ├── stm32wl/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── adc.rs
│ │ ├── blinky.rs
│ │ ├── button.rs
│ │ ├── button_exti.rs
│ │ ├── flash.rs
│ │ ├── random.rs
│ │ ├── rtc.rs
│ │ └── uart_async.rs
│ ├── stm32wl55cm0p/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── intercore.rs
│ ├── stm32wl55cm0p-lp/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── intercore.rs
│ ├── stm32wl55cm4/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ └── intercore.rs
│ ├── stm32wl55cm4-lp/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── memory.x
│ │ └── src/
│ │ └── bin/
│ │ ├── blinky.rs
│ │ └── intercore.rs
│ ├── stm32wle5-lp/
│ │ ├── .cargo/
│ │ │ └── config.toml
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── build.rs
│ │ ├── src/
│ │ │ └── bin/
│ │ │ ├── adc.rs
│ │ │ ├── blinky.rs
│ │ │ ├── button_exti.rs
│ │ │ └── i2c.rs
│ │ └── stm32wle5.code-workspace
│ └── wasm/
│ ├── Cargo.toml
│ ├── README.md
│ ├── index.html
│ └── src/
│ └── lib.rs
├── fmtall.sh
├── release/
│ ├── bump-dependency.sh
│ └── release.toml
├── rust-toolchain-nightly.toml
├── rust-toolchain.toml
├── rustfmt.toml
└── tests/
├── link_ram_cortex_m.x
├── mcxa2xx/
│ ├── .cargo/
│ │ └── config.toml
│ ├── Cargo.toml
│ ├── README.md
│ ├── build.rs
│ ├── memory.x
│ └── src/
│ └── bin/
│ ├── adc.rs
│ ├── adc_compare.rs
│ ├── cdog.rs
│ ├── crc.rs
│ ├── ctimer_capture.rs
│ ├── dma.rs
│ ├── gpio.rs
│ ├── i2c.rs
│ ├── i3c.rs
│ ├── lpuart.rs
│ ├── pwm.rs
│ ├── rtc_alarm.rs
│ ├── trng.rs
│ └── wwdt_interrupt.rs
├── mspm0/
│ ├── .cargo/
│ │ └── config.toml
│ ├── Cargo.toml
│ ├── build.rs
│ ├── memory_g3507.x
│ ├── memory_g3519.x
│ └── src/
│ └── bin/
│ ├── dma.rs
│ ├── uart.rs
│ └── uart_buffered.rs
├── nrf/
│ ├── .cargo/
│ │ └── config.toml
│ ├── Cargo.toml
│ ├── build.rs
│ ├── gen_test.py
│ ├── memory-nrf51422.x
│ ├── memory-nrf52832.x
│ ├── memory-nrf52833.x
│ ├── memory-nrf52840.x
│ ├── memory-nrf5340.x
│ ├── memory-nrf9160.x
│ └── src/
│ ├── bin/
│ │ ├── buffered_uart.rs
│ │ ├── buffered_uart_full.rs
│ │ ├── buffered_uart_halves.rs
│ │ ├── buffered_uart_spam.rs
│ │ ├── ethernet_enc28j60_perf.rs
│ │ ├── gpio.rs
│ │ ├── gpiote.rs
│ │ ├── spim.rs
│ │ ├── timer.rs
│ │ ├── uart_halves.rs
│ │ ├── uart_split.rs
│ │ └── wifi_esp_hosted_perf.rs
│ └── common.rs
├── perf-client/
│ ├── Cargo.toml
│ └── src/
│ └── lib.rs
├── perf-server/
│ ├── Cargo.toml
│ ├── deploy.sh
│ ├── perf-server.service
│ └── src/
│ └── main.rs
├── riscv32/
│ ├── .cargo/
│ │ └── config.toml
│ ├── Cargo.toml
│ ├── build.rs
│ ├── link.x
│ ├── memory.x
│ └── src/
│ └── bin/
│ └── empty.rs
├── rp/
│ ├── .cargo/
│ │ └── config.toml
│ ├── Cargo.toml
│ ├── build.rs
│ ├── memory.x
│ ├── readme.md
│ └── src/
│ └── bin/
│ ├── adc.rs
│ ├── aon_timer.rs
│ ├── bootsel.rs
│ ├── cyw43-perf.rs
│ ├── dma_copy_async.rs
│ ├── ethernet_w5100s_perf.rs
│ ├── flash.rs
│ ├── float.rs
│ ├── gpio.rs
│ ├── gpio_async.rs
│ ├── gpio_multicore.rs
│ ├── i2c.rs
│ ├── multicore.rs
│ ├── overclock.rs
│ ├── pio_irq.rs
│ ├── pio_multi_load.rs
│ ├── pwm.rs
│ ├── rtc.rs
│ ├── spi.rs
│ ├── spi_async.rs
│ ├── spinlock_mutex_multicore.rs
│ ├── timer.rs
│ ├── uart.rs
│ ├── uart_buffered.rs
│ ├── uart_dma.rs
│ └── uart_upgrade.rs
├── stm32/
│ ├── .cargo/
│ │ └── config.toml
│ ├── Cargo.toml
│ ├── build.rs
│ ├── gen_test.py
│ └── src/
│ ├── bin/
│ │ ├── adc.rs
│ │ ├── afio.rs
│ │ ├── can.rs
│ │ ├── cordic.rs
│ │ ├── cryp.rs
│ │ ├── dac.rs
│ │ ├── dac_l1.rs
│ │ ├── eeprom.rs
│ │ ├── eth.rs
│ │ ├── fdcan.rs
│ │ ├── gpio.rs
│ │ ├── hash.rs
│ │ ├── hsem.rs
│ │ ├── rng.rs
│ │ ├── rtc.rs
│ │ ├── sdmmc.rs
│ │ ├── spi.rs
│ │ ├── spi_dma.rs
│ │ ├── stop.rs
│ │ ├── timer.rs
│ │ ├── ucpd.rs
│ │ ├── usart.rs
│ │ ├── usart_dma.rs
│ │ ├── usart_rx_ringbuffered.rs
│ │ ├── wpan_ble.rs
│ │ └── wpan_mac.rs
│ ├── can_common.rs
│ └── common.rs
└── utils/
├── Cargo.toml
└── src/
└── bin/
└── saturate_serial.rs
Showing preview only (1,908K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (23404 symbols across 1730 files)
FILE: cyw43-firmware/write_nvrams.rs
function main (line 4) | fn main() -> io::Result<()> {
FILE: cyw43-pio/src/lib.rs
type PioSpi (line 19) | pub struct PioSpi<'d, PIO: Instance, const SM: usize> {
constant DEFAULT_CLOCK_DIVIDER (line 31) | pub const DEFAULT_CLOCK_DIVIDER: FixedU32<U8> = FixedU32::from_bits(0x02...
constant OVERCLOCK_CLOCK_DIVIDER (line 39) | pub const OVERCLOCK_CLOCK_DIVIDER: FixedU32<U8> = FixedU32::from_bits(0x...
constant RM2_CLOCK_DIVIDER (line 45) | pub const RM2_CLOCK_DIVIDER: FixedU32<U8> = FixedU32::from_bits(0x0300);
function new (line 52) | pub fn new(
function write (line 224) | pub async fn write(&mut self, write: &[u32]) -> u32 {
function cmd_read (line 252) | pub async fn cmd_read(&mut self, cmd: u32, read: &mut [u32]) -> u32 {
method cmd_write (line 293) | async fn cmd_write(&mut self, write: &[u32]) -> u32 {
method cmd_read (line 300) | async fn cmd_read(&mut self, write: u32, read: &mut [u32]) -> u32 {
method wait_for_event (line 307) | async fn wait_for_event(&mut self) {
FILE: cyw43/src/bluetooth.rs
type BtState (line 19) | pub(crate) struct BtState {
method new (line 26) | pub const fn new() -> Self {
type BtStateInnre (line 35) | struct BtStateInnre<'d> {
type BtDriver (line 41) | pub struct BtDriver<'d> {
type BtRunner (line 46) | pub(crate) struct BtRunner<'d> {
constant BT_HCI_MTU (line 56) | const BT_HCI_MTU: usize = 1024;
type BtPacketBuf (line 59) | pub(crate) struct BtPacketBuf {
method new (line 66) | pub const fn new() -> Self {
function new (line 74) | pub(crate) fn new<'d>(state: &'d mut BtState) -> (BtRunner<'d>, BtDriver...
type CybtFwCb (line 104) | pub(crate) struct CybtFwCb<'a> {
type HexFileData (line 108) | pub(crate) struct HexFileData<'a> {
function read_firmware_patch_line (line 115) | pub(crate) fn read_firmware_patch_line(p_btfw_cb: &mut CybtFwCb, hfd: &m...
function init_bluetooth (line 168) | pub(crate) async fn init_bluetooth(&mut self, bus: &mut impl Bus, firmwa...
function upload_bluetooth_firmware (line 181) | pub(crate) async fn upload_bluetooth_firmware(&mut self, bus: &mut impl ...
function wait_bt_ready (line 257) | pub(crate) async fn wait_bt_ready(&mut self, bus: &mut impl Bus) {
function wait_bt_awake (line 272) | pub(crate) async fn wait_bt_awake(&mut self, bus: &mut impl Bus) {
function bt_set_host_ready (line 287) | pub(crate) async fn bt_set_host_ready(&mut self, bus: &mut impl Bus) {
function bt_set_awake (line 297) | pub(crate) async fn bt_set_awake(&mut self, bus: &mut impl Bus, awake: b...
function bt_toggle_intr (line 309) | pub(crate) async fn bt_toggle_intr(&mut self, bus: &mut impl Bus) {
function bt_set_intr (line 319) | pub(crate) async fn bt_set_intr(&mut self, bus: &mut impl Bus) {
function init_bt_buffers (line 326) | pub(crate) async fn init_bt_buffers(&mut self, bus: &mut impl Bus) {
function bt_bus_request (line 337) | async fn bt_bus_request(&mut self, bus: &mut impl Bus) {
function hci_write (line 343) | pub(crate) async fn hci_write(&mut self, bus: &mut impl Bus) {
function bt_has_work (line 402) | async fn bt_has_work(&mut self, bus: &mut impl Bus) -> bool {
function handle_irq (line 415) | pub(crate) async fn handle_irq(&mut self, bus: &mut impl Bus) {
type Error (line 474) | pub enum Error {
method from (line 480) | fn from(e: FromHciBytesError) -> Self {
method fmt (line 489) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method kind (line 501) | fn kind(&self) -> ErrorKind {
type Error (line 497) | type Error = Error;
method from (line 480) | fn from(e: FromHciBytesError) -> Self {
method fmt (line 489) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method kind (line 501) | fn kind(&self) -> ErrorKind {
function read (line 509) | fn read<'a>(&self, rx: &'a mut [u8]) -> impl Future<Output = Result<Cont...
function write (line 525) | fn write<T: HostToControllerPacket>(&self, val: &T) -> impl Future<Outpu...
FILE: cyw43/src/consts.rs
constant FUNC_BUS (line 3) | pub(crate) const FUNC_BUS: u32 = 0;
constant FUNC_BACKPLANE (line 4) | pub(crate) const FUNC_BACKPLANE: u32 = 1;
constant FUNC_WLAN (line 5) | pub(crate) const FUNC_WLAN: u32 = 2;
constant FUNC_BT (line 6) | pub(crate) const FUNC_BT: u32 = 3;
constant REG_BUS_CTRL (line 9) | pub(crate) const REG_BUS_CTRL: u32 = 0x0;
constant REG_BUS_RESPONSE_DELAY (line 10) | pub(crate) const REG_BUS_RESPONSE_DELAY: u32 = 0x1;
constant REG_BUS_STATUS_ENABLE (line 11) | pub(crate) const REG_BUS_STATUS_ENABLE: u32 = 0x2;
constant REG_BUS_INTERRUPT (line 12) | pub(crate) const REG_BUS_INTERRUPT: u32 = 0x04;
constant REG_BUS_INTERRUPT_ENABLE (line 13) | pub(crate) const REG_BUS_INTERRUPT_ENABLE: u32 = 0x06;
constant REG_BUS_STATUS (line 14) | pub(crate) const REG_BUS_STATUS: u32 = 0x8;
constant REG_BUS_TEST_RO (line 15) | pub(crate) const REG_BUS_TEST_RO: u32 = 0x14;
constant REG_BUS_TEST_RW (line 16) | pub(crate) const REG_BUS_TEST_RW: u32 = 0x18;
constant REG_BUS_RESP_DELAY (line 17) | pub(crate) const REG_BUS_RESP_DELAY: u32 = 0x1c;
constant WORD_LENGTH_32 (line 20) | pub(crate) const WORD_LENGTH_32: u32 = 0x1;
constant ENDIAN_BIG (line 21) | pub(crate) const ENDIAN_BIG: u32 = 0x2;
constant CLOCK_PHASE (line 22) | pub(crate) const CLOCK_PHASE: u32 = 0x4;
constant CLOCK_POLARITY (line 23) | pub(crate) const CLOCK_POLARITY: u32 = 0x8;
constant HIGH_SPEED (line 24) | pub(crate) const HIGH_SPEED: u32 = 0x10;
constant INTERRUPT_POLARITY_HIGH (line 25) | pub(crate) const INTERRUPT_POLARITY_HIGH: u32 = 0x20;
constant WAKE_UP (line 26) | pub(crate) const WAKE_UP: u32 = 0x80;
constant STATUS_ENABLE (line 29) | pub(crate) const STATUS_ENABLE: u32 = 0x01;
constant INTR_WITH_STATUS (line 30) | pub(crate) const INTR_WITH_STATUS: u32 = 0x02;
constant RESP_DELAY_ALL (line 31) | pub(crate) const RESP_DELAY_ALL: u32 = 0x04;
constant DWORD_PKT_LEN_EN (line 32) | pub(crate) const DWORD_PKT_LEN_EN: u32 = 0x08;
constant CMD_ERR_CHK_EN (line 33) | pub(crate) const CMD_ERR_CHK_EN: u32 = 0x20;
constant DATA_ERR_CHK_EN (line 34) | pub(crate) const DATA_ERR_CHK_EN: u32 = 0x40;
constant SPI_STATUS_REGISTER (line 37) | pub(crate) const SPI_STATUS_REGISTER: u32 = 0x00000008;
constant INITIAL_READ (line 38) | pub(crate) const INITIAL_READ: u32 = 0x04;
constant STATUS_DATA_NOT_AVAILABLE (line 40) | pub(crate) const STATUS_DATA_NOT_AVAILABLE: u32 = 0x00000001;
constant STATUS_UNDERFLOW (line 41) | pub(crate) const STATUS_UNDERFLOW: u32 = 0x00000002;
constant STATUS_OVERFLOW (line 42) | pub(crate) const STATUS_OVERFLOW: u32 = 0x00000004;
constant STATUS_F2_INTR (line 43) | pub(crate) const STATUS_F2_INTR: u32 = 0x00000008;
constant STATUS_F3_INTR (line 44) | pub(crate) const STATUS_F3_INTR: u32 = 0x00000010;
constant STATUS_F2_RX_READY (line 45) | pub(crate) const STATUS_F2_RX_READY: u32 = 0x00000020;
constant STATUS_F3_RX_READY (line 46) | pub(crate) const STATUS_F3_RX_READY: u32 = 0x00000040;
constant STATUS_HOST_CMD_DATA_ERR (line 47) | pub(crate) const STATUS_HOST_CMD_DATA_ERR: u32 = 0x00000080;
constant STATUS_F2_PKT_AVAILABLE (line 48) | pub(crate) const STATUS_F2_PKT_AVAILABLE: u32 = 0x00000100;
constant STATUS_F2_PKT_LEN_MASK (line 49) | pub(crate) const STATUS_F2_PKT_LEN_MASK: u32 = 0x000FFE00;
constant STATUS_F2_PKT_LEN_SHIFT (line 50) | pub(crate) const STATUS_F2_PKT_LEN_SHIFT: u32 = 9;
constant STATUS_F3_PKT_AVAILABLE (line 51) | pub(crate) const STATUS_F3_PKT_AVAILABLE: u32 = 0x00100000;
constant STATUS_F3_PKT_LEN_MASK (line 52) | pub(crate) const STATUS_F3_PKT_LEN_MASK: u32 = 0xFFE00000;
constant STATUS_F3_PKT_LEN_SHIFT (line 53) | pub(crate) const STATUS_F3_PKT_LEN_SHIFT: u32 = 21;
constant REG_BACKPLANE_GPIO_SELECT (line 55) | pub(crate) const REG_BACKPLANE_GPIO_SELECT: u32 = 0x10005;
constant REG_BACKPLANE_GPIO_OUTPUT (line 56) | pub(crate) const REG_BACKPLANE_GPIO_OUTPUT: u32 = 0x10006;
constant REG_BACKPLANE_GPIO_ENABLE (line 57) | pub(crate) const REG_BACKPLANE_GPIO_ENABLE: u32 = 0x10007;
constant REG_BACKPLANE_FUNCTION2_WATERMARK (line 58) | pub(crate) const REG_BACKPLANE_FUNCTION2_WATERMARK: u32 = 0x10008;
constant REG_BACKPLANE_DEVICE_CONTROL (line 59) | pub(crate) const REG_BACKPLANE_DEVICE_CONTROL: u32 = 0x10009;
constant REG_BACKPLANE_BACKPLANE_ADDRESS_LOW (line 60) | pub(crate) const REG_BACKPLANE_BACKPLANE_ADDRESS_LOW: u32 = 0x1000A;
constant REG_BACKPLANE_BACKPLANE_ADDRESS_MID (line 61) | pub(crate) const REG_BACKPLANE_BACKPLANE_ADDRESS_MID: u32 = 0x1000B;
constant REG_BACKPLANE_BACKPLANE_ADDRESS_HIGH (line 62) | pub(crate) const REG_BACKPLANE_BACKPLANE_ADDRESS_HIGH: u32 = 0x1000C;
constant REG_BACKPLANE_FRAME_CONTROL (line 63) | pub(crate) const REG_BACKPLANE_FRAME_CONTROL: u32 = 0x1000D;
constant REG_BACKPLANE_CHIP_CLOCK_CSR (line 64) | pub(crate) const REG_BACKPLANE_CHIP_CLOCK_CSR: u32 = 0x1000E;
constant REG_BACKPLANE_PULL_UP (line 65) | pub(crate) const REG_BACKPLANE_PULL_UP: u32 = 0x1000F;
constant REG_BACKPLANE_READ_FRAME_BC_LOW (line 66) | pub(crate) const REG_BACKPLANE_READ_FRAME_BC_LOW: u32 = 0x1001B;
constant REG_BACKPLANE_READ_FRAME_BC_HIGH (line 67) | pub(crate) const REG_BACKPLANE_READ_FRAME_BC_HIGH: u32 = 0x1001C;
constant REG_BACKPLANE_WAKEUP_CTRL (line 68) | pub(crate) const REG_BACKPLANE_WAKEUP_CTRL: u32 = 0x1001E;
constant REG_BACKPLANE_SLEEP_CSR (line 69) | pub(crate) const REG_BACKPLANE_SLEEP_CSR: u32 = 0x1001F;
constant I_HMB_SW_MASK (line 71) | pub(crate) const I_HMB_SW_MASK: u32 = 0x000000f0;
constant I_HMB_FC_CHANGE (line 72) | pub(crate) const I_HMB_FC_CHANGE: u32 = 1 << 5;
constant SDIO_INT_STATUS (line 73) | pub(crate) const SDIO_INT_STATUS: u32 = 0x20;
constant SDIO_INT_HOST_MASK (line 74) | pub(crate) const SDIO_INT_HOST_MASK: u32 = 0x24;
constant SDIO_FUNCTION_INT_MASK (line 75) | pub(crate) const SDIO_FUNCTION_INT_MASK: u32 = 0x34;
constant SDIO_TO_SB_MAILBOX (line 76) | pub(crate) const SDIO_TO_SB_MAILBOX: u32 = 0x40;
constant SDIO_TO_SB_MAILBOX_DATA (line 77) | pub(crate) const SDIO_TO_SB_MAILBOX_DATA: u32 = 0x48;
constant SDIO_TO_HOST_MAILBOX_DATA (line 78) | pub(crate) const SDIO_TO_HOST_MAILBOX_DATA: u32 = 0x4C;
constant SDIO_SLEEP_CSR (line 79) | pub(crate) const SDIO_SLEEP_CSR: u32 = 0x1001F;
constant SBSDIO_SLPCSR_KEEP_WL_KS (line 80) | pub(crate) const SBSDIO_SLPCSR_KEEP_WL_KS: u32 = 1 << 0;
constant SMB_DEV_INT (line 82) | pub(crate) const SMB_DEV_INT: u32 = 1 << 3;
constant SMB_INT_ACK (line 83) | pub(crate) const SMB_INT_ACK: u32 = 1 << 1;
constant I_HMB_HOST_INT (line 84) | pub(crate) const I_HMB_HOST_INT: u32 = 1 << 7;
constant I_HMB_DATA_FWHALT (line 85) | pub(crate) const I_HMB_DATA_FWHALT: u32 = 0x0010;
constant HOSTINTMASK (line 87) | pub(crate) const HOSTINTMASK: u32 = 0x000000F0;
constant BUS_SD_DATA_WIDTH_MASK (line 88) | pub(crate) const BUS_SD_DATA_WIDTH_MASK: u32 = 0x03;
constant BUS_SD_DATA_WIDTH_4BIT (line 89) | pub(crate) const BUS_SD_DATA_WIDTH_4BIT: u32 = 0x02;
constant SDIO_SPEED_EHS (line 90) | pub(crate) const SDIO_SPEED_EHS: u32 = 0x02;
constant SDIOD_CCCR_BRCM_CARDCAP_SECURE_MODE (line 91) | pub(crate) const SDIOD_CCCR_BRCM_CARDCAP_SECURE_MODE: u32 = 0x80;
constant SBSDIO_DEVICE_CTL (line 92) | pub(crate) const SBSDIO_DEVICE_CTL: u32 = 0x10009;
constant SBSDIO_DEVCTL_ADDR_RST (line 93) | pub(crate) const SBSDIO_DEVCTL_ADDR_RST: u32 = 0x40;
constant SDIO_CORE_CHIPID_REG (line 94) | pub(crate) const SDIO_CORE_CHIPID_REG: u32 = 0x330;
constant SBSDIO_FUNC1_SBADDRLOW (line 96) | pub(crate) const SBSDIO_FUNC1_SBADDRLOW: u32 = 0x1000A;
constant SBSDIO_FUNC1_SBADDRMID (line 97) | pub(crate) const SBSDIO_FUNC1_SBADDRMID: u32 = 0x1000B;
constant SBSDIO_FUNC1_SBADDRHIGH (line 98) | pub(crate) const SBSDIO_FUNC1_SBADDRHIGH: u32 = 0x1000C;
constant SPI_F2_WATERMARK (line 100) | pub(crate) const SPI_F2_WATERMARK: u8 = 0x20;
constant SDIO_F2_WATERMARK (line 101) | pub(crate) const SDIO_F2_WATERMARK: u8 = 0x08;
constant BACKPLANE_WINDOW_SIZE (line 103) | pub(crate) const BACKPLANE_WINDOW_SIZE: usize = 0x8000;
constant BACKPLANE_ADDRESS_MASK (line 104) | pub(crate) const BACKPLANE_ADDRESS_MASK: u32 = 0x7FFF;
constant BACKPLANE_ADDRESS_32BIT_FLAG (line 105) | pub(crate) const BACKPLANE_ADDRESS_32BIT_FLAG: u32 = 0x08000;
constant BACKPLANE_MAX_TRANSFER_SIZE (line 106) | pub(crate) const BACKPLANE_MAX_TRANSFER_SIZE: usize = 64;
constant BLOCK_BUFFER_SIZE (line 107) | pub(crate) const BLOCK_BUFFER_SIZE: usize = 1024;
constant BACKPLANE_ALP_AVAIL_REQ (line 109) | pub(crate) const BACKPLANE_ALP_AVAIL_REQ: u8 = 0x08;
constant BACKPLANE_ALP_AVAIL (line 110) | pub(crate) const BACKPLANE_ALP_AVAIL: u8 = 0x40;
constant BACKPLANE_FORCE_HW_CLKREQ_OFF (line 111) | pub(crate) const BACKPLANE_FORCE_HW_CLKREQ_OFF: u8 = 0x20;
constant BACKPLANE_FORCE_ALP (line 112) | pub(crate) const BACKPLANE_FORCE_ALP: u8 = 0x01;
constant BACKPLANE_FORCE_HT (line 113) | pub(crate) const BACKPLANE_FORCE_HT: u32 = 0x02;
constant AI_IOCTRL_OFFSET (line 117) | pub(crate) const AI_IOCTRL_OFFSET: u32 = 0x408;
constant AI_IOCTRL_BIT_FGC (line 118) | pub(crate) const AI_IOCTRL_BIT_FGC: u8 = 0x0002;
constant AI_IOCTRL_BIT_CLOCK_EN (line 119) | pub(crate) const AI_IOCTRL_BIT_CLOCK_EN: u8 = 0x0001;
constant AI_IOCTRL_BIT_CPUHALT (line 120) | pub(crate) const AI_IOCTRL_BIT_CPUHALT: u8 = 0x0020;
constant AI_RESETCTRL_OFFSET (line 122) | pub(crate) const AI_RESETCTRL_OFFSET: u32 = 0x800;
constant AI_RESETCTRL_BIT_RESET (line 123) | pub(crate) const AI_RESETCTRL_BIT_RESET: u8 = 1;
constant AI_RESETSTATUS_OFFSET (line 125) | pub(crate) const AI_RESETSTATUS_OFFSET: u32 = 0x804;
constant TEST_PATTERN (line 127) | pub(crate) const TEST_PATTERN: u32 = 0x12345678;
constant FEEDBEAD (line 128) | pub(crate) const FEEDBEAD: u32 = 0xFEEDBEAD;
constant IRQ_DATA_UNAVAILABLE (line 131) | pub(crate) const IRQ_DATA_UNAVAILABLE: u16 = 0x0001;
constant IRQ_F2_F3_FIFO_RD_UNDERFLOW (line 132) | pub(crate) const IRQ_F2_F3_FIFO_RD_UNDERFLOW: u16 = 0x0002;
constant IRQ_F2_F3_FIFO_WR_OVERFLOW (line 133) | pub(crate) const IRQ_F2_F3_FIFO_WR_OVERFLOW: u16 = 0x0004;
constant IRQ_COMMAND_ERROR (line 134) | pub(crate) const IRQ_COMMAND_ERROR: u16 = 0x0008;
constant IRQ_DATA_ERROR (line 135) | pub(crate) const IRQ_DATA_ERROR: u16 = 0x0010;
constant IRQ_F2_PACKET_AVAILABLE (line 136) | pub(crate) const IRQ_F2_PACKET_AVAILABLE: u16 = 0x0020;
constant IRQ_F3_PACKET_AVAILABLE (line 137) | pub(crate) const IRQ_F3_PACKET_AVAILABLE: u16 = 0x0040;
constant IRQ_F1_OVERFLOW (line 138) | pub(crate) const IRQ_F1_OVERFLOW: u16 = 0x0080;
constant IRQ_MISC_INTR0 (line 139) | pub(crate) const IRQ_MISC_INTR0: u16 = 0x0100;
constant IRQ_MISC_INTR1 (line 140) | pub(crate) const IRQ_MISC_INTR1: u16 = 0x0200;
constant IRQ_MISC_INTR2 (line 141) | pub(crate) const IRQ_MISC_INTR2: u16 = 0x0400;
constant IRQ_MISC_INTR3 (line 142) | pub(crate) const IRQ_MISC_INTR3: u16 = 0x0800;
constant IRQ_MISC_INTR4 (line 143) | pub(crate) const IRQ_MISC_INTR4: u16 = 0x1000;
constant IRQ_F1_INTR (line 144) | pub(crate) const IRQ_F1_INTR: u16 = 0x2000;
constant IRQ_F2_INTR (line 145) | pub(crate) const IRQ_F2_INTR: u16 = 0x4000;
constant IRQ_F3_INTR (line 146) | pub(crate) const IRQ_F3_INTR: u16 = 0x8000;
constant CHANNEL_TYPE_CONTROL (line 148) | pub(crate) const CHANNEL_TYPE_CONTROL: u8 = 0;
constant CHANNEL_TYPE_EVENT (line 149) | pub(crate) const CHANNEL_TYPE_EVENT: u8 = 1;
constant CHANNEL_TYPE_DATA (line 150) | pub(crate) const CHANNEL_TYPE_DATA: u8 = 2;
constant WRITE (line 153) | pub(crate) const WRITE: bool = true;
constant READ (line 154) | pub(crate) const READ: bool = false;
constant INC_ADDR (line 155) | pub(crate) const INC_ADDR: bool = true;
constant FIXED_ADDR (line 156) | pub(crate) const FIXED_ADDR: bool = false;
constant AES_ENABLED (line 158) | pub(crate) const AES_ENABLED: u32 = 0x0004;
constant WPA2_SECURITY (line 159) | pub(crate) const WPA2_SECURITY: u32 = 0x00400000;
constant MIN_PSK_LEN (line 161) | pub(crate) const MIN_PSK_LEN: usize = 8;
constant MAX_PSK_LEN (line 162) | pub(crate) const MAX_PSK_LEN: usize = 64;
constant BTFW_ADDR_MODE_UNKNOWN (line 165) | pub(crate) const BTFW_ADDR_MODE_UNKNOWN: i32 = 0;
constant BTFW_ADDR_MODE_EXTENDED (line 166) | pub(crate) const BTFW_ADDR_MODE_EXTENDED: i32 = 1;
constant BTFW_ADDR_MODE_SEGMENT (line 167) | pub(crate) const BTFW_ADDR_MODE_SEGMENT: i32 = 2;
constant BTFW_ADDR_MODE_LINEAR32 (line 168) | pub(crate) const BTFW_ADDR_MODE_LINEAR32: i32 = 3;
constant BTFW_HEX_LINE_TYPE_DATA (line 170) | pub(crate) const BTFW_HEX_LINE_TYPE_DATA: u8 = 0;
constant BTFW_HEX_LINE_TYPE_END_OF_DATA (line 171) | pub(crate) const BTFW_HEX_LINE_TYPE_END_OF_DATA: u8 = 1;
constant BTFW_HEX_LINE_TYPE_EXTENDED_SEGMENT_ADDRESS (line 172) | pub(crate) const BTFW_HEX_LINE_TYPE_EXTENDED_SEGMENT_ADDRESS: u8 = 2;
constant BTFW_HEX_LINE_TYPE_EXTENDED_ADDRESS (line 173) | pub(crate) const BTFW_HEX_LINE_TYPE_EXTENDED_ADDRESS: u8 = 4;
constant BTFW_HEX_LINE_TYPE_ABSOLUTE_32BIT_ADDRESS (line 174) | pub(crate) const BTFW_HEX_LINE_TYPE_ABSOLUTE_32BIT_ADDRESS: u8 = 5;
constant SPI_RESP_DELAY_F1 (line 177) | pub(crate) const SPI_RESP_DELAY_F1: u32 = 0x001d;
constant WHD_BUS_SPI_BACKPLANE_READ_PADD_SIZE (line 178) | pub(crate) const WHD_BUS_SPI_BACKPLANE_READ_PADD_SIZE: u8 = 4;
constant BT2WLAN_PWRUP_WAKE (line 180) | pub(crate) const BT2WLAN_PWRUP_WAKE: u32 = 3;
constant BT2WLAN_PWRUP_ADDR (line 181) | pub(crate) const BT2WLAN_PWRUP_ADDR: u32 = 0x640894;
constant BT_CTRL_REG_ADDR (line 183) | pub(crate) const BT_CTRL_REG_ADDR: u32 = 0x18000c7c;
constant HOST_CTRL_REG_ADDR (line 184) | pub(crate) const HOST_CTRL_REG_ADDR: u32 = 0x18000d6c;
constant WLAN_RAM_BASE_REG_ADDR (line 185) | pub(crate) const WLAN_RAM_BASE_REG_ADDR: u32 = 0x18000d68;
constant BTSDIO_REG_DATA_VALID_BITMASK (line 187) | pub(crate) const BTSDIO_REG_DATA_VALID_BITMASK: u32 = 1 << 1;
constant BTSDIO_REG_BT_AWAKE_BITMASK (line 188) | pub(crate) const BTSDIO_REG_BT_AWAKE_BITMASK: u32 = 1 << 8;
constant BTSDIO_REG_WAKE_BT_BITMASK (line 189) | pub(crate) const BTSDIO_REG_WAKE_BT_BITMASK: u32 = 1 << 17;
constant BTSDIO_REG_SW_RDY_BITMASK (line 190) | pub(crate) const BTSDIO_REG_SW_RDY_BITMASK: u32 = 1 << 24;
constant BTSDIO_REG_FW_RDY_BITMASK (line 191) | pub(crate) const BTSDIO_REG_FW_RDY_BITMASK: u32 = 1 << 24;
constant BTSDIO_FWBUF_SIZE (line 193) | pub(crate) const BTSDIO_FWBUF_SIZE: u32 = 0x1000;
constant BTSDIO_OFFSET_HOST_WRITE_BUF (line 194) | pub(crate) const BTSDIO_OFFSET_HOST_WRITE_BUF: u32 = 0;
constant BTSDIO_OFFSET_HOST_READ_BUF (line 195) | pub(crate) const BTSDIO_OFFSET_HOST_READ_BUF: u32 = BTSDIO_FWBUF_SIZE;
constant BTSDIO_OFFSET_HOST2BT_IN (line 197) | pub(crate) const BTSDIO_OFFSET_HOST2BT_IN: u32 = 0x00002000;
constant BTSDIO_OFFSET_HOST2BT_OUT (line 198) | pub(crate) const BTSDIO_OFFSET_HOST2BT_OUT: u32 = 0x00002004;
constant BTSDIO_OFFSET_BT2HOST_IN (line 199) | pub(crate) const BTSDIO_OFFSET_BT2HOST_IN: u32 = 0x00002008;
constant BTSDIO_OFFSET_BT2HOST_OUT (line 200) | pub(crate) const BTSDIO_OFFSET_BT2HOST_OUT: u32 = 0x0000200C;
constant SDIOD_CCCR_IOEN (line 202) | pub(crate) const SDIOD_CCCR_IOEN: u32 = 0x02;
constant SDIOD_CCCR_IORDY (line 203) | pub(crate) const SDIOD_CCCR_IORDY: u32 = 0x03;
constant SDIOD_CCCR_INTEN (line 204) | pub(crate) const SDIOD_CCCR_INTEN: u32 = 0x04;
constant SDIOD_CCCR_BICTRL (line 205) | pub(crate) const SDIOD_CCCR_BICTRL: u32 = 0x07;
constant SDIOD_CCCR_BLKSIZE_0 (line 206) | pub(crate) const SDIOD_CCCR_BLKSIZE_0: u32 = 0x10;
constant SDIOD_CCCR_SPEED_CONTROL (line 207) | pub(crate) const SDIOD_CCCR_SPEED_CONTROL: u32 = 0x13;
constant SDIOD_CCCR_BRCM_CARDCAP (line 208) | pub(crate) const SDIOD_CCCR_BRCM_CARDCAP: u32 = 0xf0;
constant SDIOD_SEP_INT_CTL (line 209) | pub(crate) const SDIOD_SEP_INT_CTL: u32 = 0xf2;
constant SDIOD_CCCR_F1BLKSIZE_0 (line 210) | pub(crate) const SDIOD_CCCR_F1BLKSIZE_0: u32 = 0x110;
constant SDIOD_CCCR_F2BLKSIZE_0 (line 211) | pub(crate) const SDIOD_CCCR_F2BLKSIZE_0: u32 = 0x210;
constant SDIOD_CCCR_F2BLKSIZE_1 (line 212) | pub(crate) const SDIOD_CCCR_F2BLKSIZE_1: u32 = 0x211;
constant INTR_CTL_MASTER_EN (line 213) | pub(crate) const INTR_CTL_MASTER_EN: u32 = 0x01;
constant INTR_CTL_FUNC1_EN (line 214) | pub(crate) const INTR_CTL_FUNC1_EN: u32 = 0x02;
constant INTR_CTL_FUNC2_EN (line 215) | pub(crate) const INTR_CTL_FUNC2_EN: u32 = 0x04;
constant SDIO_FUNC_ENABLE_1 (line 216) | pub(crate) const SDIO_FUNC_ENABLE_1: u32 = 0x02;
constant SDIO_FUNC_ENABLE_2 (line 217) | pub(crate) const SDIO_FUNC_ENABLE_2: u32 = 0x04;
constant SDIO_FUNC_READY_1 (line 218) | pub(crate) const SDIO_FUNC_READY_1: u32 = 0x02;
constant SDIO_FUNC_READY_2 (line 219) | pub(crate) const SDIO_FUNC_READY_2: u32 = 0x04;
constant SDIO_64B_BLOCK (line 220) | pub(crate) const SDIO_64B_BLOCK: u32 = 64;
constant SDIO_CHIP_CLOCK_CSR (line 221) | pub(crate) const SDIO_CHIP_CLOCK_CSR: u32 = 0x1000e;
constant SDIO_PULL_UP (line 222) | pub(crate) const SDIO_PULL_UP: u32 = 0x1000f;
constant SEP_INTR_CTL_MASK (line 225) | pub(crate) const SEP_INTR_CTL_MASK: u32 = 0x01;
constant SEP_INTR_CTL_EN (line 226) | pub(crate) const SEP_INTR_CTL_EN: u32 = 0x02;
constant SEP_INTR_CTL_POL (line 227) | pub(crate) const SEP_INTR_CTL_POL: u32 = 0x04;
constant CHIPCOMMON_BASE_ADDRESS (line 229) | pub(crate) const CHIPCOMMON_BASE_ADDRESS: u32 = 0x18000000;
constant SDIO_BASE_ADDRESS (line 230) | pub(crate) const SDIO_BASE_ADDRESS: u32 = 0x18002000;
type Security (line 236) | pub(crate) enum Security {
function eq (line 283) | fn eq(&self, other: &EStatus) -> bool {
type FormatStatus (line 289) | pub(crate) struct FormatStatus(pub u32);
method format (line 293) | fn format(&self, fmt: defmt::Formatter) {
method fmt (line 321) | fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
method fmt (line 350) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
type FormatInterrupt (line 356) | pub(crate) struct FormatInterrupt(pub u16);
method format (line 360) | fn format(&self, fmt: defmt::Formatter) {
method fmt (line 394) | fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
method fmt (line 429) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
type Ioctl (line 437) | pub(crate) enum Ioctl {
constant WSEC_TKIP (line 722) | pub(crate) const WSEC_TKIP: u32 = 0x02;
constant WSEC_AES (line 723) | pub(crate) const WSEC_AES: u32 = 0x04;
constant AUTH_OPEN (line 725) | pub(crate) const AUTH_OPEN: u32 = 0x00;
constant AUTH_SAE (line 726) | pub(crate) const AUTH_SAE: u32 = 0x03;
constant MFP_NONE (line 728) | pub(crate) const MFP_NONE: u32 = 0;
constant MFP_CAPABLE (line 729) | pub(crate) const MFP_CAPABLE: u32 = 1;
constant MFP_REQUIRED (line 730) | pub(crate) const MFP_REQUIRED: u32 = 2;
constant WPA_AUTH_DISABLED (line 732) | pub(crate) const WPA_AUTH_DISABLED: u32 = 0x0000;
constant WPA_AUTH_WPA_PSK (line 733) | pub(crate) const WPA_AUTH_WPA_PSK: u32 = 0x0004;
constant WPA_AUTH_WPA2_PSK (line 734) | pub(crate) const WPA_AUTH_WPA2_PSK: u32 = 0x0080;
constant WPA_AUTH_WPA3_SAE_PSK (line 735) | pub(crate) const WPA_AUTH_WPA3_SAE_PSK: u32 = 0x40000;
FILE: cyw43/src/control.rs
type JoinError (line 20) | pub enum JoinError {
type AddMulticastAddressError (line 31) | pub enum AddMulticastAddressError {
type Control (line 39) | pub struct Control<'a> {
type ScanType (line 49) | pub enum ScanType {
type ScanOptions (line 62) | pub struct ScanOptions {
method default (line 79) | fn default() -> Self {
type JoinAuth (line 94) | pub enum JoinAuth {
type JoinOptions (line 111) | pub struct JoinOptions<'a> {
function new_open (line 131) | pub fn new_open() -> Self {
function new (line 145) | pub fn new(passphrase: &'a [u8]) -> Self {
method default (line 153) | fn default() -> Self {
function new (line 165) | pub(crate) fn new(
function load_clm (line 179) | async fn load_clm(&mut self, clm: &[u8]) {
function init (line 214) | pub async fn init(&mut self, clm: &[u8]) {
function up (line 290) | async fn up(&mut self) {
function down (line 295) | async fn down(&mut self) {
function set_power_management (line 300) | pub async fn set_power_management(&mut self, mode: PowerManagementMode) {
function join (line 313) | pub async fn join(&mut self, ssid: &str, options: JoinOptions<'_>) -> Re...
function wait_for_join (line 389) | async fn wait_for_join(&mut self, i: SsidInfo, secure_network: bool) -> ...
function gpio_set (line 443) | pub async fn gpio_set(&mut self, gpio_n: u8, gpio_en: bool) {
function start_ap_open (line 450) | pub async fn start_ap_open(&mut self, ssid: &str, channel: u8) {
function start_ap_wpa2 (line 455) | pub async fn start_ap_wpa2(&mut self, ssid: &str, passphrase: &str, chan...
function start_ap (line 459) | async fn start_ap(&mut self, ssid: &str, passphrase: &str, security: Sec...
function close_ap (line 522) | pub async fn close_ap(&mut self) {
function add_multicast_address (line 543) | pub async fn add_multicast_address(&mut self, address: [u8; 6]) -> Resul...
function list_multicast_addresses (line 573) | pub async fn list_multicast_addresses(&mut self, result: &mut [[u8; 6]; ...
function get_rssi (line 588) | pub async fn get_rssi(&mut self) -> i32 {
function set_iovar_u32x2 (line 595) | async fn set_iovar_u32x2(&mut self, name: &str, val1: u32, val2: u32) {
function set_iovar_u32 (line 602) | async fn set_iovar_u32(&mut self, name: &str, val: u32) {
function get_iovar_u32 (line 606) | async fn get_iovar_u32(&mut self, name: &str) -> u32 {
function set_iovar (line 613) | async fn set_iovar(&mut self, name: &str, val: &[u8]) {
function set_iovar_v (line 617) | async fn set_iovar_v<const BUFSIZE: usize>(&mut self, name: &str, val: &...
function get_iovar (line 631) | async fn get_iovar(&mut self, name: &str, res: &mut [u8]) -> usize {
function ioctl_set_u32 (line 648) | async fn ioctl_set_u32(&mut self, cmd: Ioctl, iface: u32, val: u32) {
function ioctl (line 653) | async fn ioctl(&mut self, kind: IoctlType, cmd: Ioctl, iface: u32, buf: ...
function ioctl_inner (line 661) | async fn ioctl_inner(&mut self, kind: IoctlType, cmd: Ioctl, iface: u32,...
function scan (line 690) | pub async fn scan(&mut self, scan_opts: ScanOptions) -> Scanner<'_> {
function leave (line 752) | pub async fn leave(&mut self) {
function address (line 758) | pub async fn address(&mut self) -> [u8; 6] {
type Scanner (line 766) | pub struct Scanner<'a> {
function next (line 773) | pub async fn next(&mut self) -> Option<BssInfo> {
method drop (line 789) | fn drop(&mut self) {
FILE: cyw43/src/countries.rs
type Country (line 3) | pub struct Country {
constant AFGHANISTAN (line 9) | pub const AFGHANISTAN: Country = Country { code: *b"AF", rev: 0 };
constant ALBANIA (line 11) | pub const ALBANIA: Country = Country { code: *b"AL", rev: 0 };
constant ALGERIA (line 13) | pub const ALGERIA: Country = Country { code: *b"DZ", rev: 0 };
constant AMERICAN_SAMOA (line 15) | pub const AMERICAN_SAMOA: Country = Country { code: *b"AS", rev: 0 };
constant ANGOLA (line 17) | pub const ANGOLA: Country = Country { code: *b"AO", rev: 0 };
constant ANGUILLA (line 19) | pub const ANGUILLA: Country = Country { code: *b"AI", rev: 0 };
constant ANTIGUA_AND_BARBUDA (line 21) | pub const ANTIGUA_AND_BARBUDA: Country = Country { code: *b"AG", rev: 0 };
constant ARGENTINA (line 23) | pub const ARGENTINA: Country = Country { code: *b"AR", rev: 0 };
constant ARMENIA (line 25) | pub const ARMENIA: Country = Country { code: *b"AM", rev: 0 };
constant ARUBA (line 27) | pub const ARUBA: Country = Country { code: *b"AW", rev: 0 };
constant AUSTRALIA (line 29) | pub const AUSTRALIA: Country = Country { code: *b"AU", rev: 0 };
constant AUSTRIA (line 31) | pub const AUSTRIA: Country = Country { code: *b"AT", rev: 0 };
constant AZERBAIJAN (line 33) | pub const AZERBAIJAN: Country = Country { code: *b"AZ", rev: 0 };
constant BAHAMAS (line 35) | pub const BAHAMAS: Country = Country { code: *b"BS", rev: 0 };
constant BAHRAIN (line 37) | pub const BAHRAIN: Country = Country { code: *b"BH", rev: 0 };
constant BAKER_ISLAND (line 39) | pub const BAKER_ISLAND: Country = Country { code: *b"0B", rev: 0 };
constant BANGLADESH (line 41) | pub const BANGLADESH: Country = Country { code: *b"BD", rev: 0 };
constant BARBADOS (line 43) | pub const BARBADOS: Country = Country { code: *b"BB", rev: 0 };
constant BELARUS (line 45) | pub const BELARUS: Country = Country { code: *b"BY", rev: 0 };
constant BELGIUM (line 47) | pub const BELGIUM: Country = Country { code: *b"BE", rev: 0 };
constant BELIZE (line 49) | pub const BELIZE: Country = Country { code: *b"BZ", rev: 0 };
constant BENIN (line 51) | pub const BENIN: Country = Country { code: *b"BJ", rev: 0 };
constant BERMUDA (line 53) | pub const BERMUDA: Country = Country { code: *b"BM", rev: 0 };
constant BHUTAN (line 55) | pub const BHUTAN: Country = Country { code: *b"BT", rev: 0 };
constant BOLIVIA (line 57) | pub const BOLIVIA: Country = Country { code: *b"BO", rev: 0 };
constant BOSNIA_AND_HERZEGOVINA (line 59) | pub const BOSNIA_AND_HERZEGOVINA: Country = Country { code: *b"BA", rev:...
constant BOTSWANA (line 61) | pub const BOTSWANA: Country = Country { code: *b"BW", rev: 0 };
constant BRAZIL (line 63) | pub const BRAZIL: Country = Country { code: *b"BR", rev: 0 };
constant BRITISH_INDIAN_OCEAN_TERRITORY (line 65) | pub const BRITISH_INDIAN_OCEAN_TERRITORY: Country = Country { code: *b"I...
constant BRUNEI_DARUSSALAM (line 67) | pub const BRUNEI_DARUSSALAM: Country = Country { code: *b"BN", rev: 0 };
constant BULGARIA (line 69) | pub const BULGARIA: Country = Country { code: *b"BG", rev: 0 };
constant BURKINA_FASO (line 71) | pub const BURKINA_FASO: Country = Country { code: *b"BF", rev: 0 };
constant BURUNDI (line 73) | pub const BURUNDI: Country = Country { code: *b"BI", rev: 0 };
constant CAMBODIA (line 75) | pub const CAMBODIA: Country = Country { code: *b"KH", rev: 0 };
constant CAMEROON (line 77) | pub const CAMEROON: Country = Country { code: *b"CM", rev: 0 };
constant CANADA (line 79) | pub const CANADA: Country = Country { code: *b"CA", rev: 0 };
constant CANADA_REV950 (line 81) | pub const CANADA_REV950: Country = Country { code: *b"CA", rev: 950 };
constant CAPE_VERDE (line 83) | pub const CAPE_VERDE: Country = Country { code: *b"CV", rev: 0 };
constant CAYMAN_ISLANDS (line 85) | pub const CAYMAN_ISLANDS: Country = Country { code: *b"KY", rev: 0 };
constant CENTRAL_AFRICAN_REPUBLIC (line 87) | pub const CENTRAL_AFRICAN_REPUBLIC: Country = Country { code: *b"CF", re...
constant CHAD (line 89) | pub const CHAD: Country = Country { code: *b"TD", rev: 0 };
constant CHILE (line 91) | pub const CHILE: Country = Country { code: *b"CL", rev: 0 };
constant CHINA (line 93) | pub const CHINA: Country = Country { code: *b"CN", rev: 0 };
constant CHRISTMAS_ISLAND (line 95) | pub const CHRISTMAS_ISLAND: Country = Country { code: *b"CX", rev: 0 };
constant COLOMBIA (line 97) | pub const COLOMBIA: Country = Country { code: *b"CO", rev: 0 };
constant COMOROS (line 99) | pub const COMOROS: Country = Country { code: *b"KM", rev: 0 };
constant CONGO (line 101) | pub const CONGO: Country = Country { code: *b"CG", rev: 0 };
constant CONGO_THE_DEMOCRATIC_REPUBLIC_OF_THE (line 103) | pub const CONGO_THE_DEMOCRATIC_REPUBLIC_OF_THE: Country = Country { code...
constant COSTA_RICA (line 105) | pub const COSTA_RICA: Country = Country { code: *b"CR", rev: 0 };
constant COTE_DIVOIRE (line 107) | pub const COTE_DIVOIRE: Country = Country { code: *b"CI", rev: 0 };
constant CROATIA (line 109) | pub const CROATIA: Country = Country { code: *b"HR", rev: 0 };
constant CUBA (line 111) | pub const CUBA: Country = Country { code: *b"CU", rev: 0 };
constant CYPRUS (line 113) | pub const CYPRUS: Country = Country { code: *b"CY", rev: 0 };
constant CZECH_REPUBLIC (line 115) | pub const CZECH_REPUBLIC: Country = Country { code: *b"CZ", rev: 0 };
constant DENMARK (line 117) | pub const DENMARK: Country = Country { code: *b"DK", rev: 0 };
constant DJIBOUTI (line 119) | pub const DJIBOUTI: Country = Country { code: *b"DJ", rev: 0 };
constant DOMINICA (line 121) | pub const DOMINICA: Country = Country { code: *b"DM", rev: 0 };
constant DOMINICAN_REPUBLIC (line 123) | pub const DOMINICAN_REPUBLIC: Country = Country { code: *b"DO", rev: 0 };
constant DOWN_UNDER (line 125) | pub const DOWN_UNDER: Country = Country { code: *b"AU", rev: 0 };
constant ECUADOR (line 127) | pub const ECUADOR: Country = Country { code: *b"EC", rev: 0 };
constant EGYPT (line 129) | pub const EGYPT: Country = Country { code: *b"EG", rev: 0 };
constant EL_SALVADOR (line 131) | pub const EL_SALVADOR: Country = Country { code: *b"SV", rev: 0 };
constant EQUATORIAL_GUINEA (line 133) | pub const EQUATORIAL_GUINEA: Country = Country { code: *b"GQ", rev: 0 };
constant ERITREA (line 135) | pub const ERITREA: Country = Country { code: *b"ER", rev: 0 };
constant ESTONIA (line 137) | pub const ESTONIA: Country = Country { code: *b"EE", rev: 0 };
constant ETHIOPIA (line 139) | pub const ETHIOPIA: Country = Country { code: *b"ET", rev: 0 };
constant FALKLAND_ISLANDS_MALVINAS (line 141) | pub const FALKLAND_ISLANDS_MALVINAS: Country = Country { code: *b"FK", r...
constant FAROE_ISLANDS (line 143) | pub const FAROE_ISLANDS: Country = Country { code: *b"FO", rev: 0 };
constant FIJI (line 145) | pub const FIJI: Country = Country { code: *b"FJ", rev: 0 };
constant FINLAND (line 147) | pub const FINLAND: Country = Country { code: *b"FI", rev: 0 };
constant FRANCE (line 149) | pub const FRANCE: Country = Country { code: *b"FR", rev: 0 };
constant FRENCH_GUINA (line 151) | pub const FRENCH_GUINA: Country = Country { code: *b"GF", rev: 0 };
constant FRENCH_POLYNESIA (line 153) | pub const FRENCH_POLYNESIA: Country = Country { code: *b"PF", rev: 0 };
constant FRENCH_SOUTHERN_TERRITORIES (line 155) | pub const FRENCH_SOUTHERN_TERRITORIES: Country = Country { code: *b"TF",...
constant GABON (line 157) | pub const GABON: Country = Country { code: *b"GA", rev: 0 };
constant GAMBIA (line 159) | pub const GAMBIA: Country = Country { code: *b"GM", rev: 0 };
constant GEORGIA (line 161) | pub const GEORGIA: Country = Country { code: *b"GE", rev: 0 };
constant GERMANY (line 163) | pub const GERMANY: Country = Country { code: *b"DE", rev: 0 };
constant EUROPEAN_WIDE_REV895 (line 165) | pub const EUROPEAN_WIDE_REV895: Country = Country { code: *b"E0", rev: 8...
constant GHANA (line 167) | pub const GHANA: Country = Country { code: *b"GH", rev: 0 };
constant GIBRALTAR (line 169) | pub const GIBRALTAR: Country = Country { code: *b"GI", rev: 0 };
constant GREECE (line 171) | pub const GREECE: Country = Country { code: *b"GR", rev: 0 };
constant GRENADA (line 173) | pub const GRENADA: Country = Country { code: *b"GD", rev: 0 };
constant GUADELOUPE (line 175) | pub const GUADELOUPE: Country = Country { code: *b"GP", rev: 0 };
constant GUAM (line 177) | pub const GUAM: Country = Country { code: *b"GU", rev: 0 };
constant GUATEMALA (line 179) | pub const GUATEMALA: Country = Country { code: *b"GT", rev: 0 };
constant GUERNSEY (line 181) | pub const GUERNSEY: Country = Country { code: *b"GG", rev: 0 };
constant GUINEA (line 183) | pub const GUINEA: Country = Country { code: *b"GN", rev: 0 };
constant GUINEA_BISSAU (line 185) | pub const GUINEA_BISSAU: Country = Country { code: *b"GW", rev: 0 };
constant GUYANA (line 187) | pub const GUYANA: Country = Country { code: *b"GY", rev: 0 };
constant HAITI (line 189) | pub const HAITI: Country = Country { code: *b"HT", rev: 0 };
constant HOLY_SEE_VATICAN_CITY_STATE (line 191) | pub const HOLY_SEE_VATICAN_CITY_STATE: Country = Country { code: *b"VA",...
constant HONDURAS (line 193) | pub const HONDURAS: Country = Country { code: *b"HN", rev: 0 };
constant HONG_KONG (line 195) | pub const HONG_KONG: Country = Country { code: *b"HK", rev: 0 };
constant HUNGARY (line 197) | pub const HUNGARY: Country = Country { code: *b"HU", rev: 0 };
constant ICELAND (line 199) | pub const ICELAND: Country = Country { code: *b"IS", rev: 0 };
constant INDIA (line 201) | pub const INDIA: Country = Country { code: *b"IN", rev: 0 };
constant INDONESIA (line 203) | pub const INDONESIA: Country = Country { code: *b"ID", rev: 0 };
constant IRAN_ISLAMIC_REPUBLIC_OF (line 205) | pub const IRAN_ISLAMIC_REPUBLIC_OF: Country = Country { code: *b"IR", re...
constant IRAQ (line 207) | pub const IRAQ: Country = Country { code: *b"IQ", rev: 0 };
constant IRELAND (line 209) | pub const IRELAND: Country = Country { code: *b"IE", rev: 0 };
constant ISRAEL (line 211) | pub const ISRAEL: Country = Country { code: *b"IL", rev: 0 };
constant ITALY (line 213) | pub const ITALY: Country = Country { code: *b"IT", rev: 0 };
constant JAMAICA (line 215) | pub const JAMAICA: Country = Country { code: *b"JM", rev: 0 };
constant JAPAN (line 217) | pub const JAPAN: Country = Country { code: *b"JP", rev: 0 };
constant JERSEY (line 219) | pub const JERSEY: Country = Country { code: *b"JE", rev: 0 };
constant JORDAN (line 221) | pub const JORDAN: Country = Country { code: *b"JO", rev: 0 };
constant KAZAKHSTAN (line 223) | pub const KAZAKHSTAN: Country = Country { code: *b"KZ", rev: 0 };
constant KENYA (line 225) | pub const KENYA: Country = Country { code: *b"KE", rev: 0 };
constant KIRIBATI (line 227) | pub const KIRIBATI: Country = Country { code: *b"KI", rev: 0 };
constant KOREA_REPUBLIC_OF (line 229) | pub const KOREA_REPUBLIC_OF: Country = Country { code: *b"KR", rev: 1 };
constant KOSOVO (line 231) | pub const KOSOVO: Country = Country { code: *b"0A", rev: 0 };
constant KUWAIT (line 233) | pub const KUWAIT: Country = Country { code: *b"KW", rev: 0 };
constant KYRGYZSTAN (line 235) | pub const KYRGYZSTAN: Country = Country { code: *b"KG", rev: 0 };
constant LAO_PEOPLES_DEMOCRATIC_REPUBIC (line 237) | pub const LAO_PEOPLES_DEMOCRATIC_REPUBIC: Country = Country { code: *b"L...
constant LATVIA (line 239) | pub const LATVIA: Country = Country { code: *b"LV", rev: 0 };
constant LEBANON (line 241) | pub const LEBANON: Country = Country { code: *b"LB", rev: 0 };
constant LESOTHO (line 243) | pub const LESOTHO: Country = Country { code: *b"LS", rev: 0 };
constant LIBERIA (line 245) | pub const LIBERIA: Country = Country { code: *b"LR", rev: 0 };
constant LIBYAN_ARAB_JAMAHIRIYA (line 247) | pub const LIBYAN_ARAB_JAMAHIRIYA: Country = Country { code: *b"LY", rev:...
constant LIECHTENSTEIN (line 249) | pub const LIECHTENSTEIN: Country = Country { code: *b"LI", rev: 0 };
constant LITHUANIA (line 251) | pub const LITHUANIA: Country = Country { code: *b"LT", rev: 0 };
constant LUXEMBOURG (line 253) | pub const LUXEMBOURG: Country = Country { code: *b"LU", rev: 0 };
constant MACAO (line 255) | pub const MACAO: Country = Country { code: *b"MO", rev: 0 };
constant MACEDONIA_FORMER_YUGOSLAV_REPUBLIC_OF (line 257) | pub const MACEDONIA_FORMER_YUGOSLAV_REPUBLIC_OF: Country = Country { cod...
constant MADAGASCAR (line 259) | pub const MADAGASCAR: Country = Country { code: *b"MG", rev: 0 };
constant MALAWI (line 261) | pub const MALAWI: Country = Country { code: *b"MW", rev: 0 };
constant MALAYSIA (line 263) | pub const MALAYSIA: Country = Country { code: *b"MY", rev: 0 };
constant MALDIVES (line 265) | pub const MALDIVES: Country = Country { code: *b"MV", rev: 0 };
constant MALI (line 267) | pub const MALI: Country = Country { code: *b"ML", rev: 0 };
constant MALTA (line 269) | pub const MALTA: Country = Country { code: *b"MT", rev: 0 };
constant MAN_ISLE_OF (line 271) | pub const MAN_ISLE_OF: Country = Country { code: *b"IM", rev: 0 };
constant MARTINIQUE (line 273) | pub const MARTINIQUE: Country = Country { code: *b"MQ", rev: 0 };
constant MAURITANIA (line 275) | pub const MAURITANIA: Country = Country { code: *b"MR", rev: 0 };
constant MAURITIUS (line 277) | pub const MAURITIUS: Country = Country { code: *b"MU", rev: 0 };
constant MAYOTTE (line 279) | pub const MAYOTTE: Country = Country { code: *b"YT", rev: 0 };
constant MEXICO (line 281) | pub const MEXICO: Country = Country { code: *b"MX", rev: 0 };
constant MICRONESIA_FEDERATED_STATES_OF (line 283) | pub const MICRONESIA_FEDERATED_STATES_OF: Country = Country { code: *b"F...
constant MOLDOVA_REPUBLIC_OF (line 285) | pub const MOLDOVA_REPUBLIC_OF: Country = Country { code: *b"MD", rev: 0 };
constant MONACO (line 287) | pub const MONACO: Country = Country { code: *b"MC", rev: 0 };
constant MONGOLIA (line 289) | pub const MONGOLIA: Country = Country { code: *b"MN", rev: 0 };
constant MONTENEGRO (line 291) | pub const MONTENEGRO: Country = Country { code: *b"ME", rev: 0 };
constant MONTSERRAT (line 293) | pub const MONTSERRAT: Country = Country { code: *b"MS", rev: 0 };
constant MOROCCO (line 295) | pub const MOROCCO: Country = Country { code: *b"MA", rev: 0 };
constant MOZAMBIQUE (line 297) | pub const MOZAMBIQUE: Country = Country { code: *b"MZ", rev: 0 };
constant MYANMAR (line 299) | pub const MYANMAR: Country = Country { code: *b"MM", rev: 0 };
constant NAMIBIA (line 301) | pub const NAMIBIA: Country = Country { code: *b"NA", rev: 0 };
constant NAURU (line 303) | pub const NAURU: Country = Country { code: *b"NR", rev: 0 };
constant NEPAL (line 305) | pub const NEPAL: Country = Country { code: *b"NP", rev: 0 };
constant NETHERLANDS (line 307) | pub const NETHERLANDS: Country = Country { code: *b"NL", rev: 0 };
constant NETHERLANDS_ANTILLES (line 309) | pub const NETHERLANDS_ANTILLES: Country = Country { code: *b"AN", rev: 0 };
constant NEW_CALEDONIA (line 311) | pub const NEW_CALEDONIA: Country = Country { code: *b"NC", rev: 0 };
constant NEW_ZEALAND (line 313) | pub const NEW_ZEALAND: Country = Country { code: *b"NZ", rev: 0 };
constant NICARAGUA (line 315) | pub const NICARAGUA: Country = Country { code: *b"NI", rev: 0 };
constant NIGER (line 317) | pub const NIGER: Country = Country { code: *b"NE", rev: 0 };
constant NIGERIA (line 319) | pub const NIGERIA: Country = Country { code: *b"NG", rev: 0 };
constant NORFOLK_ISLAND (line 321) | pub const NORFOLK_ISLAND: Country = Country { code: *b"NF", rev: 0 };
constant NORTHERN_MARIANA_ISLANDS (line 323) | pub const NORTHERN_MARIANA_ISLANDS: Country = Country { code: *b"MP", re...
constant NORWAY (line 325) | pub const NORWAY: Country = Country { code: *b"NO", rev: 0 };
constant OMAN (line 327) | pub const OMAN: Country = Country { code: *b"OM", rev: 0 };
constant PAKISTAN (line 329) | pub const PAKISTAN: Country = Country { code: *b"PK", rev: 0 };
constant PALAU (line 331) | pub const PALAU: Country = Country { code: *b"PW", rev: 0 };
constant PANAMA (line 333) | pub const PANAMA: Country = Country { code: *b"PA", rev: 0 };
constant PAPUA_NEW_GUINEA (line 335) | pub const PAPUA_NEW_GUINEA: Country = Country { code: *b"PG", rev: 0 };
constant PARAGUAY (line 337) | pub const PARAGUAY: Country = Country { code: *b"PY", rev: 0 };
constant PERU (line 339) | pub const PERU: Country = Country { code: *b"PE", rev: 0 };
constant PHILIPPINES (line 341) | pub const PHILIPPINES: Country = Country { code: *b"PH", rev: 0 };
constant POLAND (line 343) | pub const POLAND: Country = Country { code: *b"PL", rev: 0 };
constant PORTUGAL (line 345) | pub const PORTUGAL: Country = Country { code: *b"PT", rev: 0 };
constant PUETO_RICO (line 347) | pub const PUETO_RICO: Country = Country { code: *b"PR", rev: 0 };
constant QATAR (line 349) | pub const QATAR: Country = Country { code: *b"QA", rev: 0 };
constant REUNION (line 351) | pub const REUNION: Country = Country { code: *b"RE", rev: 0 };
constant ROMANIA (line 353) | pub const ROMANIA: Country = Country { code: *b"RO", rev: 0 };
constant RUSSIAN_FEDERATION (line 355) | pub const RUSSIAN_FEDERATION: Country = Country { code: *b"RU", rev: 0 };
constant RWANDA (line 357) | pub const RWANDA: Country = Country { code: *b"RW", rev: 0 };
constant SAINT_KITTS_AND_NEVIS (line 359) | pub const SAINT_KITTS_AND_NEVIS: Country = Country { code: *b"KN", rev: ...
constant SAINT_LUCIA (line 361) | pub const SAINT_LUCIA: Country = Country { code: *b"LC", rev: 0 };
constant SAINT_PIERRE_AND_MIQUELON (line 363) | pub const SAINT_PIERRE_AND_MIQUELON: Country = Country { code: *b"PM", r...
constant SAINT_VINCENT_AND_THE_GRENADINES (line 365) | pub const SAINT_VINCENT_AND_THE_GRENADINES: Country = Country { code: *b...
constant SAMOA (line 367) | pub const SAMOA: Country = Country { code: *b"WS", rev: 0 };
constant SANIT_MARTIN_SINT_MARTEEN (line 369) | pub const SANIT_MARTIN_SINT_MARTEEN: Country = Country { code: *b"MF", r...
constant SAO_TOME_AND_PRINCIPE (line 371) | pub const SAO_TOME_AND_PRINCIPE: Country = Country { code: *b"ST", rev: ...
constant SAUDI_ARABIA (line 373) | pub const SAUDI_ARABIA: Country = Country { code: *b"SA", rev: 0 };
constant SENEGAL (line 375) | pub const SENEGAL: Country = Country { code: *b"SN", rev: 0 };
constant SERBIA (line 377) | pub const SERBIA: Country = Country { code: *b"RS", rev: 0 };
constant SEYCHELLES (line 379) | pub const SEYCHELLES: Country = Country { code: *b"SC", rev: 0 };
constant SIERRA_LEONE (line 381) | pub const SIERRA_LEONE: Country = Country { code: *b"SL", rev: 0 };
constant SINGAPORE (line 383) | pub const SINGAPORE: Country = Country { code: *b"SG", rev: 0 };
constant SLOVAKIA (line 385) | pub const SLOVAKIA: Country = Country { code: *b"SK", rev: 0 };
constant SLOVENIA (line 387) | pub const SLOVENIA: Country = Country { code: *b"SI", rev: 0 };
constant SOLOMON_ISLANDS (line 389) | pub const SOLOMON_ISLANDS: Country = Country { code: *b"SB", rev: 0 };
constant SOMALIA (line 391) | pub const SOMALIA: Country = Country { code: *b"SO", rev: 0 };
constant SOUTH_AFRICA (line 393) | pub const SOUTH_AFRICA: Country = Country { code: *b"ZA", rev: 0 };
constant SPAIN (line 395) | pub const SPAIN: Country = Country { code: *b"ES", rev: 0 };
constant SRI_LANKA (line 397) | pub const SRI_LANKA: Country = Country { code: *b"LK", rev: 0 };
constant SURINAME (line 399) | pub const SURINAME: Country = Country { code: *b"SR", rev: 0 };
constant SWAZILAND (line 401) | pub const SWAZILAND: Country = Country { code: *b"SZ", rev: 0 };
constant SWEDEN (line 403) | pub const SWEDEN: Country = Country { code: *b"SE", rev: 0 };
constant SWITZERLAND (line 405) | pub const SWITZERLAND: Country = Country { code: *b"CH", rev: 0 };
constant SYRIAN_ARAB_REPUBLIC (line 407) | pub const SYRIAN_ARAB_REPUBLIC: Country = Country { code: *b"SY", rev: 0 };
constant TAIWAN_PROVINCE_OF_CHINA (line 409) | pub const TAIWAN_PROVINCE_OF_CHINA: Country = Country { code: *b"TW", re...
constant TAJIKISTAN (line 411) | pub const TAJIKISTAN: Country = Country { code: *b"TJ", rev: 0 };
constant TANZANIA_UNITED_REPUBLIC_OF (line 413) | pub const TANZANIA_UNITED_REPUBLIC_OF: Country = Country { code: *b"TZ",...
constant THAILAND (line 415) | pub const THAILAND: Country = Country { code: *b"TH", rev: 0 };
constant TOGO (line 417) | pub const TOGO: Country = Country { code: *b"TG", rev: 0 };
constant TONGA (line 419) | pub const TONGA: Country = Country { code: *b"TO", rev: 0 };
constant TRINIDAD_AND_TOBAGO (line 421) | pub const TRINIDAD_AND_TOBAGO: Country = Country { code: *b"TT", rev: 0 };
constant TUNISIA (line 423) | pub const TUNISIA: Country = Country { code: *b"TN", rev: 0 };
constant TURKEY (line 425) | pub const TURKEY: Country = Country { code: *b"TR", rev: 0 };
constant TURKMENISTAN (line 427) | pub const TURKMENISTAN: Country = Country { code: *b"TM", rev: 0 };
constant TURKS_AND_CAICOS_ISLANDS (line 429) | pub const TURKS_AND_CAICOS_ISLANDS: Country = Country { code: *b"TC", re...
constant TUVALU (line 431) | pub const TUVALU: Country = Country { code: *b"TV", rev: 0 };
constant UGANDA (line 433) | pub const UGANDA: Country = Country { code: *b"UG", rev: 0 };
constant UKRAINE (line 435) | pub const UKRAINE: Country = Country { code: *b"UA", rev: 0 };
constant UNITED_ARAB_EMIRATES (line 437) | pub const UNITED_ARAB_EMIRATES: Country = Country { code: *b"AE", rev: 0 };
constant UNITED_KINGDOM (line 439) | pub const UNITED_KINGDOM: Country = Country { code: *b"GB", rev: 0 };
constant UNITED_STATES (line 441) | pub const UNITED_STATES: Country = Country { code: *b"US", rev: 0 };
constant UNITED_STATES_REV4 (line 443) | pub const UNITED_STATES_REV4: Country = Country { code: *b"US", rev: 4 };
constant UNITED_STATES_REV931 (line 445) | pub const UNITED_STATES_REV931: Country = Country { code: *b"Q1", rev: 9...
constant UNITED_STATES_NO_DFS (line 447) | pub const UNITED_STATES_NO_DFS: Country = Country { code: *b"Q2", rev: 0 };
constant UNITED_STATES_MINOR_OUTLYING_ISLANDS (line 449) | pub const UNITED_STATES_MINOR_OUTLYING_ISLANDS: Country = Country { code...
constant URUGUAY (line 451) | pub const URUGUAY: Country = Country { code: *b"UY", rev: 0 };
constant UZBEKISTAN (line 453) | pub const UZBEKISTAN: Country = Country { code: *b"UZ", rev: 0 };
constant VANUATU (line 455) | pub const VANUATU: Country = Country { code: *b"VU", rev: 0 };
constant VENEZUELA (line 457) | pub const VENEZUELA: Country = Country { code: *b"VE", rev: 0 };
constant VIET_NAM (line 459) | pub const VIET_NAM: Country = Country { code: *b"VN", rev: 0 };
constant VIRGIN_ISLANDS_BRITISH (line 461) | pub const VIRGIN_ISLANDS_BRITISH: Country = Country { code: *b"VG", rev:...
constant VIRGIN_ISLANDS_US (line 463) | pub const VIRGIN_ISLANDS_US: Country = Country { code: *b"VI", rev: 0 };
constant WALLIS_AND_FUTUNA (line 465) | pub const WALLIS_AND_FUTUNA: Country = Country { code: *b"WF", rev: 0 };
constant WEST_BANK (line 467) | pub const WEST_BANK: Country = Country { code: *b"0C", rev: 0 };
constant WESTERN_SAHARA (line 469) | pub const WESTERN_SAHARA: Country = Country { code: *b"EH", rev: 0 };
constant WORLD_WIDE_XV_REV983 (line 471) | pub const WORLD_WIDE_XV_REV983: Country = Country { code: *b"XV", rev: 9...
constant WORLD_WIDE_XX (line 473) | pub const WORLD_WIDE_XX: Country = Country { code: *b"XX", rev: 0 };
constant WORLD_WIDE_XX_REV17 (line 475) | pub const WORLD_WIDE_XX_REV17: Country = Country { code: *b"XX", rev: 17 };
constant YEMEN (line 477) | pub const YEMEN: Country = Country { code: *b"YE", rev: 0 };
constant ZAMBIA (line 479) | pub const ZAMBIA: Country = Country { code: *b"ZM", rev: 0 };
constant ZIMBABWE (line 481) | pub const ZIMBABWE: Country = Country { code: *b"ZW", rev: 0 };
FILE: cyw43/src/events.rs
type EventQueue (line 291) | pub type EventQueue = PubSubChannel<NoopRawMutex, Message, 2, 1, 1>;
type EventSubscriber (line 292) | pub type EventSubscriber<'a> = Subscriber<'a, NoopRawMutex, Message, 2, ...
type Events (line 294) | pub struct Events {
method new (line 300) | pub const fn new() -> Self {
type Status (line 310) | pub struct Status {
type Payload (line 316) | pub enum Payload {
type Message (line 323) | pub struct Message {
method new (line 329) | pub fn new(status: Status, payload: Payload) -> Self {
type EventMask (line 337) | struct EventMask {
constant WORD_COUNT (line 342) | const WORD_COUNT: usize = ((Event::LAST as u32 + (u32::BITS - 1)) / u3...
method new (line 344) | const fn new() -> Self {
method enable (line 350) | fn enable(&mut self, event: Event) {
method disable (line 358) | fn disable(&mut self, event: Event) {
method is_enabled (line 366) | fn is_enabled(&self, event: Event) -> bool {
type SharedEventMask (line 375) | pub struct SharedEventMask {
method new (line 380) | pub const fn new() -> Self {
method enable (line 386) | pub fn enable(&self, events: &[Event]) {
method disable (line 394) | pub fn disable(&self, events: &[Event]) {
method disable_all (line 401) | pub fn disable_all(&self) {
method is_enabled (line 406) | pub fn is_enabled(&self, event: Event) -> bool {
method default (line 413) | fn default() -> Self {
FILE: cyw43/src/fmt.rs
type NoneError (line 217) | pub struct NoneError;
type Try (line 219) | pub trait Try {
method into_result (line 222) | fn into_result(self) -> Result<Self::Ok, Self::Error>;
type Ok (line 226) | type Ok = T;
type Error (line 227) | type Error = NoneError;
method into_result (line 230) | fn into_result(self) -> Result<T, NoneError> {
type Ok (line 236) | type Ok = T;
type Error (line 237) | type Error = E;
method into_result (line 240) | fn into_result(self) -> Self {
type Bytes (line 245) | pub(crate) struct Bytes<'a>(pub &'a [u8]);
method fmt (line 248) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 254) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 260) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
function format (line 267) | fn format(&self, fmt: defmt::Formatter) {
FILE: cyw43/src/ioctl.rs
type IoctlType (line 11) | pub enum IoctlType {
type PendingIoctl (line 17) | pub struct PendingIoctl {
type IoctlStateInner (line 25) | enum IoctlStateInner {
type Wakers (line 31) | struct Wakers {
method new (line 37) | const fn new() -> Self {
type IoctlState (line 45) | pub struct IoctlState {
method new (line 51) | pub const fn new() -> Self {
method wake_control (line 58) | fn wake_control(&self) {
method register_control (line 62) | fn register_control(&self, waker: &Waker) {
method wake_runner (line 66) | fn wake_runner(&self) {
method register_runner (line 70) | fn register_runner(&self, waker: &Waker) {
method wait_complete (line 74) | pub fn wait_complete(&self) -> impl Future<Output = usize> + '_ {
method wait_pending (line 85) | pub fn wait_pending(&self) -> impl Future<Output = PendingIoctl> + '_ {
method cancel_ioctl (line 97) | pub fn cancel_ioctl(&self) {
method do_ioctl (line 101) | pub async fn do_ioctl(&self, kind: IoctlType, cmd: Ioctl, iface: u32, ...
method ioctl_done (line 108) | pub fn ioctl_done(&self, response: &[u8]) {
FILE: cyw43/src/lib.rs
constant MTU (line 42) | const MTU: usize = 1514;
type Core (line 46) | enum Core {
method base_addr (line 53) | fn base_addr(&self) -> u32 {
type Chip (line 63) | struct Chip {
constant WRAPPER_REGISTER_OFFSET (line 88) | const WRAPPER_REGISTER_OFFSET: u32 = 0x100000;
constant CHIP (line 91) | const CHIP: Chip = Chip {
type State (line 117) | pub struct State {
method new (line 132) | pub const fn new() -> Self {
type NetState (line 124) | struct NetState {
type PowerManagementMode (line 148) | pub enum PowerManagementMode {
method sleep_ret_ms (line 179) | fn sleep_ret_ms(&self) -> u16 {
method beacon_period (line 190) | fn beacon_period(&self) -> u8 {
method dtim_period (line 201) | fn dtim_period(&self) -> u8 {
method assoc (line 212) | fn assoc(&self) -> u8 {
method mode (line 223) | fn mode(&self) -> u32 {
method default (line 173) | fn default() -> Self {
type NetDriver (line 233) | pub type NetDriver<'a> = ch::Device<'a, MTU>;
function new (line 239) | pub async fn new<'a, PWR, SPI>(
function new_sdio (line 278) | pub async fn new_sdio<'a, SDIO>(
function new_with_bluetooth (line 316) | pub async fn new_with_bluetooth<'a, PWR, SPI>(
FILE: cyw43/src/runner.rs
type LogState (line 20) | struct LogState {
method default (line 29) | fn default() -> Self {
type BusType (line 39) | pub(crate) enum BusType {
type SealedBus (line 44) | pub(crate) trait SealedBus {
constant TYPE (line 45) | const TYPE: BusType;
method init (line 47) | async fn init(&mut self, bluetooth_enabled: bool);
method wlan_read (line 48) | async fn wlan_read(&mut self, buf: &mut Aligned<A4, [u8]>);
method wlan_write (line 49) | async fn wlan_write(&mut self, buf: &Aligned<A4, [u8]>);
method bp_read (line 51) | async fn bp_read(&mut self, addr: u32, data: &mut [u8]);
method bp_write (line 52) | async fn bp_write(&mut self, addr: u32, data: &[u8]);
method bp_read8 (line 53) | async fn bp_read8(&mut self, addr: u32) -> u8;
method bp_write8 (line 54) | async fn bp_write8(&mut self, addr: u32, val: u8);
method bp_read16 (line 55) | async fn bp_read16(&mut self, addr: u32) -> u16;
method bp_write16 (line 57) | async fn bp_write16(&mut self, addr: u32, val: u16);
method bp_read32 (line 59) | async fn bp_read32(&mut self, addr: u32) -> u32;
method bp_write32 (line 60) | async fn bp_write32(&mut self, addr: u32, val: u32);
method read8 (line 61) | async fn read8(&mut self, func: u32, addr: u32) -> u8;
method write8 (line 62) | async fn write8(&mut self, func: u32, addr: u32, val: u8);
method read16 (line 63) | async fn read16(&mut self, func: u32, addr: u32) -> u16;
method write16 (line 64) | async fn write16(&mut self, func: u32, addr: u32, val: u16);
method read32 (line 65) | async fn read32(&mut self, func: u32, addr: u32) -> u32;
method write32 (line 67) | async fn write32(&mut self, func: u32, addr: u32, val: u32);
method wait_for_event (line 68) | async fn wait_for_event(&mut self);
type Bus (line 72) | pub trait Bus: SealedBus {}
type Runner (line 76) | pub struct Runner<'a, BUS> {
function new (line 103) | pub(crate) fn new(
function init (line 130) | pub(crate) async fn init(
function log_init (line 401) | async fn log_init(&mut self) {
function log_read (line 416) | async fn log_read(&mut self) {
function run (line 455) | pub async fn run(mut self) -> ! {
function handle_irq (line 579) | async fn handle_irq(&mut self, buf: &mut [u32; 512]) {
function check_status (line 638) | async fn check_status(&mut self, buf: &mut [u32; 512]) {
function rx (line 695) | fn rx(&mut self, packet: &mut [u8]) {
function update_credit (line 888) | fn update_credit(&mut self, sdpcm_header: &SdpcmHeader) {
function has_credit (line 898) | fn has_credit(&self) -> bool {
function send_ioctl (line 902) | async fn send_ioctl(&mut self, kind: IoctlType, cmd: Ioctl, iface: u32, ...
function core_disable (line 943) | async fn core_disable(&mut self, core: Core) {
function core_reset (line 966) | async fn core_reset(&mut self, core: Core) {
function core_is_up (line 987) | async fn core_is_up(&mut self, core: Core) -> bool {
FILE: cyw43/src/sdio.rs
type Mode (line 25) | enum Mode {
type Word (line 33) | enum Word {
constant BLOCK_SIZE (line 39) | const BLOCK_SIZE: usize = BACKPLANE_MAX_TRANSFER_SIZE;
function cmd53_arg (line 41) | fn cmd53_arg(write: bool, func: u32, addr: u32, mode: Mode, len: usize) ...
type SdioBusCyw43 (line 54) | pub trait SdioBusCyw43<const SIZE: usize> {
method set_bus_to_high_speed (line 59) | fn set_bus_to_high_speed(&mut self, frequency: u32) -> Result<(), Self...
method cmd52 (line 62) | async fn cmd52(&mut self, arg: u32) -> Result<u16, Self::Error>;
method cmd53_block_read (line 65) | async fn cmd53_block_read(&mut self, arg: u32, blocks: &mut [Aligned<A...
method cmd53_byte_read (line 68) | async fn cmd53_byte_read(&mut self, arg: u32, buffer: &mut Aligned<A4,...
method cmd53_block_write (line 71) | async fn cmd53_block_write(&mut self, arg: u32, blocks: &[Aligned<A4, ...
method cmd53_byte_write (line 74) | async fn cmd53_byte_write(&mut self, arg: u32, buffer: &Aligned<A4, [u...
method wait_for_event (line 78) | async fn wait_for_event(&mut self) {
type Error (line 84) | type Error = T::Error;
function set_bus_to_high_speed (line 86) | fn set_bus_to_high_speed(&mut self, frequency: u32) -> Result<(), Self::...
function cmd52 (line 90) | async fn cmd52(&mut self, arg: u32) -> Result<u16, Self::Error> {
function cmd53_block_read (line 94) | async fn cmd53_block_read(&mut self, arg: u32, blocks: &mut [Aligned<A4,...
function cmd53_byte_read (line 98) | async fn cmd53_byte_read(&mut self, arg: u32, buffer: &mut Aligned<A4, [...
function cmd53_block_write (line 102) | async fn cmd53_block_write(&mut self, arg: u32, blocks: &[Aligned<A4, [u...
function cmd53_byte_write (line 106) | async fn cmd53_byte_write(&mut self, arg: u32, buffer: &Aligned<A4, [u8]...
function wait_for_event (line 110) | async fn wait_for_event(&mut self) {
type SdioBus (line 116) | pub struct SdioBus<SDIO> {
function new (line 125) | pub(crate) fn new(sdio: SDIO) -> Self {
function backplane_readn (line 132) | async fn backplane_readn(&mut self, addr: u32, word: Word) -> u32 {
function backplane_writen (line 155) | async fn backplane_writen(&mut self, addr: u32, val: u32, word: Word) {
function backplane_set_window (line 174) | async fn backplane_set_window(&mut self, addr: u32) {
function cmd52 (line 204) | async fn cmd52(&mut self, write: bool, func: u32, addr: u32, val: u8) ->...
function cmd53_write (line 214) | async fn cmd53_write(&mut self, func: u32, mut addr: u32, buf: &Aligned<...
function cmd53_read (line 249) | async fn cmd53_read(&mut self, func: u32, mut addr: u32, buf: &mut Align...
constant TYPE (line 289) | const TYPE: BusType = BusType::Sdio;
method init (line 291) | async fn init(&mut self, _bluetooth_enabled: bool) {
method wlan_read (line 374) | async fn wlan_read(&mut self, buf: &mut Aligned<A4, [u8]>) {
method wlan_write (line 378) | async fn wlan_write(&mut self, buf: &Aligned<A4, [u8]>) {
method bp_read (line 383) | async fn bp_read(&mut self, mut addr: u32, mut data: &mut [u8]) {
method bp_write (line 419) | async fn bp_write(&mut self, mut addr: u32, data: &[u8]) {
method bp_read8 (line 456) | async fn bp_read8(&mut self, addr: u32) -> u8 {
method bp_write8 (line 460) | async fn bp_write8(&mut self, addr: u32, val: u8) {
method bp_read16 (line 464) | async fn bp_read16(&mut self, addr: u32) -> u16 {
method bp_write16 (line 469) | async fn bp_write16(&mut self, addr: u32, val: u16) {
method bp_read32 (line 474) | async fn bp_read32(&mut self, addr: u32) -> u32 {
method bp_write32 (line 478) | async fn bp_write32(&mut self, addr: u32, val: u32) {
method read8 (line 482) | async fn read8(&mut self, func: u32, addr: u32) -> u8 {
method write8 (line 486) | async fn write8(&mut self, func: u32, addr: u32, val: u8) {
method read16 (line 490) | async fn read16(&mut self, func: u32, addr: u32) -> u16 {
method write16 (line 498) | async fn write16(&mut self, func: u32, addr: u32, val: u16) {
method read32 (line 502) | async fn read32(&mut self, func: u32, addr: u32) -> u32 {
method write32 (line 510) | async fn write32(&mut self, func: u32, addr: u32, val: u32) {
method wait_for_event (line 514) | async fn wait_for_event(&mut self) {
FILE: cyw43/src/spi.rs
type SpiBusCyw43 (line 13) | pub trait SpiBusCyw43 {
method cmd_write (line 16) | async fn cmd_write(&mut self, write: &[u32]) -> u32;
method cmd_read (line 23) | async fn cmd_read(&mut self, write: u32, read: &mut [u32]) -> u32;
method wait_for_event (line 27) | async fn wait_for_event(&mut self) {
type SpiBus (line 33) | pub struct SpiBus<PWR, SPI> {
function new (line 45) | pub(crate) fn new(pwr: PWR, spi: SPI) -> Self {
function backplane_readn (line 54) | async fn backplane_readn(&mut self, addr: u32, len: u32) -> u32 {
function backplane_writen (line 71) | async fn backplane_writen(&mut self, addr: u32, val: u32, len: u32) {
function backplane_set_window (line 83) | async fn backplane_set_window(&mut self, addr: u32) {
function readn (line 113) | async fn readn(&mut self, func: u32, addr: u32, len: u32) -> u32 {
function writen (line 125) | async fn writen(&mut self, func: u32, addr: u32, val: u32, len: u32) {
function read32_swapped (line 131) | async fn read32_swapped(&mut self, func: u32, addr: u32) -> u32 {
function write32_swapped (line 141) | async fn write32_swapped(&mut self, func: u32, addr: u32, val: u32) {
constant TYPE (line 154) | const TYPE: BusType = BusType::Spi;
method init (line 156) | async fn init(&mut self, bluetooth_enabled: bool) {
method wlan_read (line 243) | async fn wlan_read(&mut self, buf: &mut Aligned<A4, [u8]>) {
method wlan_write (line 253) | async fn wlan_write(&mut self, buf: &Aligned<A4, [u8]>) {
method bp_read (line 265) | async fn bp_read(&mut self, mut addr: u32, mut data: &mut [u8]) {
method bp_write (line 300) | async fn bp_write(&mut self, mut addr: u32, mut data: &[u8]) {
method bp_read8 (line 332) | async fn bp_read8(&mut self, addr: u32) -> u8 {
method bp_write8 (line 336) | async fn bp_write8(&mut self, addr: u32, val: u8) {
method bp_read16 (line 340) | async fn bp_read16(&mut self, addr: u32) -> u16 {
method bp_write16 (line 345) | async fn bp_write16(&mut self, addr: u32, val: u16) {
method bp_read32 (line 350) | async fn bp_read32(&mut self, addr: u32) -> u32 {
method bp_write32 (line 354) | async fn bp_write32(&mut self, addr: u32, val: u32) {
method read8 (line 358) | async fn read8(&mut self, func: u32, addr: u32) -> u8 {
method write8 (line 362) | async fn write8(&mut self, func: u32, addr: u32, val: u8) {
method read16 (line 366) | async fn read16(&mut self, func: u32, addr: u32) -> u16 {
method write16 (line 371) | async fn write16(&mut self, func: u32, addr: u32, val: u16) {
method read32 (line 375) | async fn read32(&mut self, func: u32, addr: u32) -> u32 {
method write32 (line 387) | async fn write32(&mut self, func: u32, addr: u32, val: u32) {
method wait_for_event (line 391) | async fn wait_for_event(&mut self) {
function swap16 (line 396) | fn swap16(x: u32) -> u32 {
function cmd_word (line 400) | fn cmd_word(write: bool, incr: bool, func: u32, addr: u32, len: u32) -> ...
FILE: cyw43/src/structs.rs
type SharedMemData (line 49) | pub struct SharedMemData {
type SharedMemLog (line 64) | pub struct SharedMemLog {
type SdpcmHeader (line 75) | pub struct SdpcmHeader {
method parse (line 96) | pub fn parse(packet: &mut [u8]) -> Option<(&mut Self, &mut [u8])> {
type CdcHeader (line 123) | pub struct CdcHeader {
method format (line 134) | fn format(&self, fmt: defmt::Formatter) {
method parse (line 152) | pub fn parse(packet: &mut [u8]) -> Option<(&mut Self, &mut [u8])> {
constant BDC_VERSION (line 166) | pub const BDC_VERSION: u8 = 2;
constant BDC_VERSION_SHIFT (line 167) | pub const BDC_VERSION_SHIFT: u8 = 4;
type BdcHeader (line 172) | pub struct BdcHeader {
method parse (line 183) | pub fn parse(packet: &mut [u8]) -> Option<(&mut Self, &mut [u8])> {
type EthernetHeader (line 204) | pub struct EthernetHeader {
method byteswap (line 212) | pub fn byteswap(&mut self) {
type EventHeader (line 220) | pub struct EventHeader {
method byteswap (line 229) | pub fn byteswap(&mut self) {
type EventMessage (line 239) | pub struct EventMessage {
method format (line 267) | fn format(&self, fmt: defmt::Formatter) {
method byteswap (line 305) | pub fn byteswap(&mut self) {
type EventPacket (line 319) | pub struct EventPacket {
method parse (line 327) | pub fn parse(packet: &mut [u8]) -> Option<(&mut Self, &mut [u8])> {
method byteswap (line 342) | pub fn byteswap(&mut self) {
type DownloadHeader (line 351) | pub struct DownloadHeader {
constant DOWNLOAD_FLAG_NO_CRC (line 360) | pub const DOWNLOAD_FLAG_NO_CRC: u16 = 0x0001;
constant DOWNLOAD_FLAG_BEGIN (line 361) | pub const DOWNLOAD_FLAG_BEGIN: u16 = 0x0002;
constant DOWNLOAD_FLAG_END (line 362) | pub const DOWNLOAD_FLAG_END: u16 = 0x0004;
constant DOWNLOAD_FLAG_HANDLER_VER (line 363) | pub const DOWNLOAD_FLAG_HANDLER_VER: u16 = 0x1000;
constant DOWNLOAD_TYPE_CLM (line 366) | pub const DOWNLOAD_TYPE_CLM: u16 = 2;
type CountryInfo (line 371) | pub struct CountryInfo {
type SsidInfo (line 381) | pub struct SsidInfo {
type PassphraseInfo (line 390) | pub struct PassphraseInfo {
type SaePassphraseInfo (line 400) | pub struct SaePassphraseInfo {
type SsidInfoWithIndex (line 409) | pub struct SsidInfoWithIndex {
type EventMask (line 418) | pub struct EventMask {
method unset (line 425) | pub fn unset(&mut self, evt: Event) {
type ScanParams (line 435) | pub struct ScanParams {
type ScanResults (line 457) | pub struct ScanResults {
method parse (line 466) | pub fn parse(packet: &mut [u8]) -> Option<(&mut ScanResults, &mut [u8]...
type BssInfo (line 488) | pub struct BssInfo {
method parse (line 546) | pub(crate) fn parse(packet: &mut [u8]) -> Option<&mut Self> {
FILE: cyw43/src/util.rs
function slice8_mut (line 51) | pub(crate) const fn slice8_mut(x: &mut [u32]) -> &mut [u8] {
function slice16_mut (line 56) | pub(crate) const fn slice16_mut(x: &mut [u32]) -> &mut [u16] {
function aligned_mut (line 61) | pub(crate) const fn aligned_mut(x: &mut [u32]) -> &mut Aligned<A4, [u8]> {
function aligned_ref (line 66) | pub(crate) const fn aligned_ref(x: &[u32]) -> &Aligned<A4, [u8]> {
function slice32_mut (line 71) | pub(crate) const fn slice32_mut(x: &mut Aligned<A4, [u8]>) -> &mut [u32] {
function slice32_ref (line 76) | pub(crate) const fn slice32_ref(x: &Aligned<A4, [u8]>) -> &[u32] {
function is_aligned (line 81) | pub(crate) fn is_aligned(a: u32, x: u32) -> bool {
function round_down (line 85) | pub(crate) fn round_down(x: u32, a: u32) -> u32 {
function round_up (line 89) | pub(crate) fn round_up(x: u32, a: u32) -> u32 {
function try_until (line 93) | pub(crate) async fn try_until(mut func: impl AsyncFnMut() -> bool, durat...
FILE: docs/examples/basic/build.rs
function main (line 16) | fn main() {
FILE: docs/examples/basic/src/main.rs
function blink (line 13) | async fn blink(pin: Peri<'static, AnyPin>) {
function main (line 27) | async fn main(spawner: Spawner) {
FILE: docs/examples/layer-by-layer/blinky-async/src/main.rs
function main (line 16) | async fn main(_spawner: Spawner) {
FILE: docs/examples/layer-by-layer/blinky-hal/src/main.rs
function main (line 9) | fn main() -> ! {
FILE: docs/examples/layer-by-layer/blinky-irq/src/main.rs
function main (line 17) | fn main() -> ! {
function EXTI15_10 (line 37) | fn EXTI15_10() {
constant PORT (line 62) | const PORT: u8 = 2;
constant PIN (line 63) | const PIN: usize = 13;
function check_interrupt (line 64) | fn check_interrupt(_pin: &mut Input<'static>) -> bool {
function clear_interrupt (line 71) | fn clear_interrupt(_pin: &mut Input<'static>) {
function enable_interrupt (line 79) | fn enable_interrupt(_pin: &mut Input<'static>) {
FILE: docs/examples/layer-by-layer/blinky-pac/src/main.rs
function main (line 8) | fn main() -> ! {
FILE: embassy-boot-nrf/src/fmt.rs
type NoneError (line 217) | pub struct NoneError;
type Try (line 219) | pub trait Try {
method into_result (line 222) | fn into_result(self) -> Result<Self::Ok, Self::Error>;
type Ok (line 226) | type Ok = T;
type Error (line 227) | type Error = NoneError;
method into_result (line 230) | fn into_result(self) -> Result<T, NoneError> {
type Ok (line 236) | type Ok = T;
type Error (line 237) | type Error = E;
method into_result (line 240) | fn into_result(self) -> Self {
type Bytes (line 245) | pub(crate) struct Bytes<'a>(pub &'a [u8]);
method fmt (line 248) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 254) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 260) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
function format (line 267) | fn format(&self, fmt: defmt::Formatter) {
FILE: embassy-boot-nrf/src/lib.rs
type BootLoader (line 16) | pub struct BootLoader<const BUFFER_SIZE: usize = PAGE_SIZE>;
function prepare (line 20) | pub fn prepare<ACTIVE: NorFlash, DFU: NorFlash, STATE: NorFlash>(
function try_prepare (line 33) | pub fn try_prepare<ACTIVE: NorFlash, DFU: NorFlash, STATE: NorFlash>(
function load (line 48) | pub unsafe fn load(self, start: u32) -> ! {
function load (line 61) | pub unsafe fn load(self, _app: u32) -> ! {
type WatchdogFlash (line 109) | pub struct WatchdogFlash<FLASH> {
function start (line 116) | pub fn start(flash: FLASH, wdt: Peri<'static, impl wdt::Instance>, confi...
type Error (line 132) | type Error = FLASH::Error;
constant WRITE_SIZE (line 136) | const WRITE_SIZE: usize = FLASH::WRITE_SIZE;
constant ERASE_SIZE (line 137) | const ERASE_SIZE: usize = FLASH::ERASE_SIZE;
method erase (line 139) | fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
method write (line 143) | fn write(&mut self, offset: u32, data: &[u8]) -> Result<(), Self::Error> {
constant READ_SIZE (line 150) | const READ_SIZE: usize = FLASH::READ_SIZE;
method read (line 151) | fn read(&mut self, offset: u32, data: &mut [u8]) -> Result<(), Self::Err...
method capacity (line 155) | fn capacity(&self) -> usize {
FILE: embassy-boot-rp/build.rs
function main (line 3) | fn main() {
FILE: embassy-boot-rp/src/fmt.rs
type NoneError (line 217) | pub struct NoneError;
type Try (line 219) | pub trait Try {
method into_result (line 222) | fn into_result(self) -> Result<Self::Ok, Self::Error>;
type Ok (line 226) | type Ok = T;
type Error (line 227) | type Error = NoneError;
method into_result (line 230) | fn into_result(self) -> Result<T, NoneError> {
type Ok (line 236) | type Ok = T;
type Error (line 237) | type Error = E;
method into_result (line 240) | fn into_result(self) -> Self {
type Bytes (line 245) | pub(crate) struct Bytes<'a>(pub &'a [u8]);
method fmt (line 248) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 254) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 260) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
function format (line 267) | fn format(&self, fmt: defmt::Formatter) {
FILE: embassy-boot-rp/src/lib.rs
type BootLoader (line 19) | pub struct BootLoader<const BUFFER_SIZE: usize = ERASE_SIZE> {
function prepare (line 26) | pub fn prepare<ACTIVE: NorFlash, DFU: NorFlash, STATE: NorFlash>(
function try_prepare (line 39) | pub fn try_prepare<ACTIVE: NorFlash, DFU: NorFlash, STATE: NorFlash>(
function load (line 53) | pub unsafe fn load(self, start: u32) -> ! {
type WatchdogFlash (line 66) | pub struct WatchdogFlash<'d, const SIZE: usize> {
function start (line 74) | pub fn start(flash: Peri<'static, FLASH>, watchdog: Peri<'static, WATCHD...
type Error (line 87) | type Error = <Flash<'d, FLASH, Blocking, SIZE> as ErrorType>::Error;
constant WRITE_SIZE (line 91) | const WRITE_SIZE: usize = <Flash<'d, FLASH, Blocking, SIZE> as NorFlash>...
constant ERASE_SIZE (line 92) | const ERASE_SIZE: usize = <Flash<'d, FLASH, Blocking, SIZE> as NorFlash>...
method erase (line 94) | fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
method write (line 98) | fn write(&mut self, offset: u32, data: &[u8]) -> Result<(), Self::Error> {
constant READ_SIZE (line 105) | const READ_SIZE: usize = <Flash<'d, FLASH, Blocking, SIZE> as ReadNorFla...
method read (line 106) | fn read(&mut self, offset: u32, data: &mut [u8]) -> Result<(), Self::Err...
method capacity (line 110) | fn capacity(&self) -> usize {
FILE: embassy-boot-stm32/build.rs
function main (line 3) | fn main() {
FILE: embassy-boot-stm32/src/fmt.rs
type NoneError (line 217) | pub struct NoneError;
type Try (line 219) | pub trait Try {
method into_result (line 222) | fn into_result(self) -> Result<Self::Ok, Self::Error>;
type Ok (line 226) | type Ok = T;
type Error (line 227) | type Error = NoneError;
method into_result (line 230) | fn into_result(self) -> Result<T, NoneError> {
type Ok (line 236) | type Ok = T;
type Error (line 237) | type Error = E;
method into_result (line 240) | fn into_result(self) -> Self {
type Bytes (line 245) | pub(crate) struct Bytes<'a>(pub &'a [u8]);
method fmt (line 248) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 254) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 260) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
function format (line 267) | fn format(&self, fmt: defmt::Formatter) {
FILE: embassy-boot-stm32/src/lib.rs
type BootLoader (line 14) | pub struct BootLoader {
method prepare (line 21) | pub fn prepare<ACTIVE: NorFlash, DFU: NorFlash, STATE: NorFlash, const...
method try_prepare (line 34) | pub fn try_prepare<ACTIVE: NorFlash, DFU: NorFlash, STATE: NorFlash, c...
method load (line 48) | pub unsafe fn load(self, start: u32) -> ! {
FILE: embassy-boot/src/boot_loader.rs
type BootError (line 12) | pub enum BootError {
method format (line 21) | fn format(&self, fmt: defmt::Formatter) {
method from (line 33) | fn from(error: E) -> Self {
type BootLoaderConfig (line 43) | pub struct BootLoaderConfig<ACTIVE, DFU, STATE> {
function from_linkerfile_blocking (line 92) | pub fn from_linkerfile_blocking(
type BootLoader (line 133) | pub struct BootLoader<ACTIVE: NorFlash, DFU: NorFlash, STATE: NorFlash> {
constant PAGE_SIZE (line 149) | const PAGE_SIZE: u32 = if ACTIVE::ERASE_SIZE > DFU::ERASE_SIZE {
function new (line 159) | pub fn new(config: BootLoaderConfig<ACTIVE, DFU, STATE>) -> Self {
function prepare_boot (line 239) | pub fn prepare_boot(&mut self, aligned_buf: &mut [u8]) -> Result<State, ...
function read_state (line 289) | pub fn read_state(&mut self, aligned_buf: &mut [u8]) -> Result<State, Bo...
function is_swapped (line 304) | fn is_swapped(&mut self, aligned_buf: &mut [u8]) -> Result<bool, BootErr...
function current_progress (line 311) | fn current_progress(&mut self, aligned_buf: &mut [u8]) -> Result<usize, ...
function update_progress (line 332) | fn update_progress(&mut self, progress_index: usize, aligned_buf: &mut [...
function copy_page_once_to_active (line 340) | fn copy_page_once_to_active(
function copy_page_once_to_dfu (line 362) | fn copy_page_once_to_dfu(
function swap (line 384) | fn swap(&mut self, aligned_buf: &mut [u8]) -> Result<(), BootError> {
function revert (line 405) | fn revert(&mut self, aligned_buf: &mut [u8]) -> Result<(), BootError> {
function assert_partitions (line 425) | fn assert_partitions<ACTIVE: NorFlash, DFU: NorFlash, STATE: NorFlash>(
function test_range_asserts (line 445) | fn test_range_asserts() {
FILE: embassy-boot/src/digest_adapters/ed25519_dalek.rs
type Sha512 (line 5) | pub struct Sha512(ed25519_dalek::Sha512);
method default (line 8) | fn default() -> Self {
method update (line 14) | fn update(&mut self, data: &[u8]) {
method finalize_into (line 20) | fn finalize_into(self, out: &mut digest::Output<Self>) {
type OutputSize (line 27) | type OutputSize = U64;
FILE: embassy-boot/src/digest_adapters/salty.rs
type Sha512 (line 4) | pub struct Sha512(salty::Sha512);
method default (line 7) | fn default() -> Self {
method update (line 13) | fn update(&mut self, data: &[u8]) {
method finalize_into (line 19) | fn finalize_into(self, out: &mut digest::Output<Self>) {
type OutputSize (line 26) | type OutputSize = U64;
FILE: embassy-boot/src/firmware_updater/asynch.rs
type FirmwareUpdater (line 13) | pub struct FirmwareUpdater<'d, DFU: NorFlash, STATE: NorFlash> {
function from_linkerfile (line 24) | pub fn from_linkerfile(
function new (line 56) | pub fn new(config: FirmwareUpdaterConfig<DFU, STATE>, aligned: &'d mut [...
function get_state (line 69) | pub async fn get_state(&mut self) -> Result<State, FirmwareUpdaterError> {
function verify_and_mark_updated (line 85) | pub async fn verify_and_mark_updated(
function hash (line 148) | pub async fn hash<D: Digest>(
function read_dfu (line 170) | pub async fn read_dfu(&mut self, offset: u32, buf: &mut [u8]) -> Result<...
function mark_updated (line 177) | pub async fn mark_updated(&mut self) -> Result<(), FirmwareUpdaterError> {
function mark_dfu (line 182) | pub async fn mark_dfu(&mut self) -> Result<(), FirmwareUpdaterError> {
function mark_booted (line 188) | pub async fn mark_booted(&mut self) -> Result<(), FirmwareUpdaterError> {
function write_firmware (line 217) | pub async fn write_firmware(&mut self, offset: usize, data: &[u8]) -> Re...
function prepare_update (line 263) | pub async fn prepare_update(&mut self) -> Result<&mut DFU, FirmwareUpdat...
type FirmwareState (line 274) | pub struct FirmwareState<'d, STATE> {
function from_config (line 286) | pub fn from_config<DFU: NorFlash>(config: FirmwareUpdaterConfig<DFU, STA...
function new (line 296) | pub fn new(state: STATE, aligned: &'d mut [u8]) -> Self {
function verify_booted (line 302) | async fn verify_booted(&mut self) -> Result<(), FirmwareUpdaterError> {
function get_state (line 316) | pub async fn get_state(&mut self) -> Result<State, FirmwareUpdaterError> {
function mark_updated (line 322) | pub async fn mark_updated(&mut self) -> Result<(), FirmwareUpdaterError> {
function mark_dfu (line 327) | pub async fn mark_dfu(&mut self) -> Result<(), FirmwareUpdaterError> {
function mark_booted (line 332) | pub async fn mark_booted(&mut self) -> Result<(), FirmwareUpdaterError> {
function set_magic (line 336) | async fn set_magic(&mut self, magic: u8) -> Result<(), FirmwareUpdaterEr...
function can_verify_sha1 (line 383) | fn can_verify_sha1() {
function can_verify_sha1_sector_bigger_than_chunk (line 403) | fn can_verify_sha1_sector_bigger_than_chunk() {
function can_verify_sha1_sector_smaller_than_chunk (line 427) | fn can_verify_sha1_sector_smaller_than_chunk() {
function can_verify_sha1_cross_sector_boundary (line 451) | fn can_verify_sha1_cross_sector_boundary() {
FILE: embassy-boot/src/firmware_updater/blocking.rs
type BlockingFirmwareUpdater (line 13) | pub struct BlockingFirmwareUpdater<'d, DFU: NorFlash, STATE: NorFlash> {
function from_linkerfile_blocking (line 54) | pub fn from_linkerfile_blocking(
function new (line 91) | pub fn new(config: FirmwareUpdaterConfig<DFU, STATE>, aligned: &'d mut [...
function get_state (line 104) | pub fn get_state(&mut self) -> Result<State, FirmwareUpdaterError> {
function verify_and_mark_updated (line 120) | pub fn verify_and_mark_updated(
function hash (line 183) | pub fn hash<D: Digest>(
function read_dfu (line 205) | pub fn read_dfu(&mut self, offset: u32, buf: &mut [u8]) -> Result<(), Fi...
function mark_updated (line 212) | pub fn mark_updated(&mut self) -> Result<(), FirmwareUpdaterError> {
function mark_dfu (line 217) | pub fn mark_dfu(&mut self) -> Result<(), FirmwareUpdaterError> {
function mark_booted (line 223) | pub fn mark_booted(&mut self) -> Result<(), FirmwareUpdaterError> {
function write_firmware (line 252) | pub fn write_firmware(&mut self, offset: usize, data: &[u8]) -> Result<(...
function prepare_update (line 298) | pub fn prepare_update(&mut self) -> Result<&mut DFU, FirmwareUpdaterErro...
type BlockingFirmwareState (line 309) | pub struct BlockingFirmwareState<'d, STATE> {
function from_config (line 321) | pub fn from_config<DFU: NorFlash>(config: FirmwareUpdaterConfig<DFU, STA...
function new (line 331) | pub fn new(state: STATE, aligned: &'d mut [u8]) -> Self {
function verify_booted (line 337) | fn verify_booted(&mut self) -> Result<(), FirmwareUpdaterError> {
function get_state (line 351) | pub fn get_state(&mut self) -> Result<State, FirmwareUpdaterError> {
function mark_updated (line 357) | pub fn mark_updated(&mut self) -> Result<(), FirmwareUpdaterError> {
function mark_dfu (line 362) | pub fn mark_dfu(&mut self) -> Result<(), FirmwareUpdaterError> {
function mark_booted (line 367) | pub fn mark_booted(&mut self) -> Result<(), FirmwareUpdaterError> {
function set_magic (line 371) | fn set_magic(&mut self, magic: u8) -> Result<(), FirmwareUpdaterError> {
function can_verify_sha1 (line 410) | fn can_verify_sha1() {
function can_verify_sha1_sector_bigger_than_chunk (line 432) | fn can_verify_sha1_sector_bigger_than_chunk() {
function can_verify_sha1_sector_smaller_than_chunk (line 458) | fn can_verify_sha1_sector_smaller_than_chunk() {
function can_verify_sha1_cross_sector_boundary (line 484) | fn can_verify_sha1_cross_sector_boundary() {
FILE: embassy-boot/src/firmware_updater/mod.rs
type FirmwareUpdaterConfig (line 13) | pub struct FirmwareUpdaterConfig<DFU, STATE> {
type FirmwareUpdaterError (line 22) | pub enum FirmwareUpdaterError {
method format (line 33) | fn format(&self, fmt: defmt::Formatter) {
method from (line 46) | fn from(error: E) -> Self {
FILE: embassy-boot/src/fmt.rs
type NoneError (line 217) | pub struct NoneError;
type Try (line 219) | pub trait Try {
method into_result (line 222) | fn into_result(self) -> Result<Self::Ok, Self::Error>;
type Ok (line 226) | type Ok = T;
type Error (line 227) | type Error = NoneError;
method into_result (line 230) | fn into_result(self) -> Result<T, NoneError> {
type Ok (line 236) | type Ok = T;
type Error (line 237) | type Error = E;
method into_result (line 240) | fn into_result(self) -> Self {
type Bytes (line 245) | pub(crate) struct Bytes<'a>(pub &'a [u8]);
method fmt (line 248) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 254) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 260) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
function format (line 267) | fn format(&self, fmt: defmt::Formatter) {
FILE: embassy-boot/src/lib.rs
constant STATE_ERASE_VALUE (line 23) | pub(crate) const STATE_ERASE_VALUE: u8 = 0xFF;
constant STATE_ERASE_VALUE (line 25) | pub(crate) const STATE_ERASE_VALUE: u8 = 0x00;
constant REVERT_MAGIC (line 33) | pub(crate) const REVERT_MAGIC: u8 = 0xC0;
constant BOOT_MAGIC (line 34) | pub(crate) const BOOT_MAGIC: u8 = 0xD0;
constant SWAP_MAGIC (line 35) | pub(crate) const SWAP_MAGIC: u8 = 0xF0;
constant DFU_DETACH_MAGIC (line 36) | pub(crate) const DFU_DETACH_MAGIC: u8 = 0xE0;
type State (line 41) | pub enum State {
method from (line 56) | fn from(magic: T) -> State {
type AlignedBuffer (line 72) | pub struct AlignedBuffer<const N: usize>(pub [u8; N]);
function as_ref (line 75) | fn as_ref(&self) -> &[u8] {
function as_mut (line 81) | fn as_mut(&mut self) -> &mut [u8] {
function test_boot_state (line 116) | fn test_boot_state() {
function test_swap_state (line 137) | fn test_swap_state() {
function test_swap_state_active_page_biggest (line 218) | fn test_swap_state_active_page_biggest() {
function test_swap_state_dfu_page_biggest (line 263) | fn test_swap_state_dfu_page_biggest() {
function test_verify (line 307) | fn test_verify() {
FILE: embassy-boot/src/mem_flash.rs
type MemFlash (line 8) | pub struct MemFlash<const SIZE: usize, const ERASE_SIZE: usize, const WR...
type MemFlashError (line 14) | pub struct MemFlashError;
function new (line 17) | pub const fn new(fill: u8) -> Self {
function random (line 25) | pub fn random() -> Self {
function read (line 36) | fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), MemFlash...
function write (line 42) | fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), MemFlashErr...
function erase (line 71) | fn erase(&mut self, from: u32, to: u32) -> Result<(), MemFlashError> {
function program (line 82) | pub fn program(&mut self, offset: u32, bytes: &[u8]) -> Result<(), MemFl...
method default (line 97) | fn default() -> Self {
type Error (line 105) | type Error = MemFlashError;
method kind (line 109) | fn kind(&self) -> NorFlashErrorKind {
constant READ_SIZE (line 117) | const READ_SIZE: usize = 1;
method read (line 119) | fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Er...
method capacity (line 123) | fn capacity(&self) -> usize {
constant WRITE_SIZE (line 131) | const WRITE_SIZE: usize = WRITE_SIZE;
constant ERASE_SIZE (line 132) | const ERASE_SIZE: usize = ERASE_SIZE;
method write (line 134) | fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error> {
method erase (line 138) | fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
constant READ_SIZE (line 146) | const READ_SIZE: usize = 1;
method read (line 148) | async fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Se...
method capacity (line 152) | fn capacity(&self) -> usize {
constant WRITE_SIZE (line 160) | const WRITE_SIZE: usize = WRITE_SIZE;
constant ERASE_SIZE (line 161) | const ERASE_SIZE: usize = ERASE_SIZE;
method write (line 163) | async fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self:...
method erase (line 167) | async fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
FILE: embassy-boot/src/test_flash/asynch.rs
type AsyncTestFlash (line 8) | pub struct AsyncTestFlash<ACTIVE, DFU, STATE>
function new (line 25) | pub fn new(config: BootLoaderConfig<ACTIVE, DFU, STATE>) -> Self {
function active (line 33) | pub fn active(&self) -> Partition<NoopRawMutex, ACTIVE> {
function dfu (line 37) | pub fn dfu(&self) -> Partition<NoopRawMutex, DFU> {
function state (line 41) | pub fn state(&self) -> Partition<NoopRawMutex, STATE> {
function create_partition (line 45) | fn create_partition<T: NorFlash>(mutex: &Mutex<NoopRawMutex, T>) -> Part...
function into_blocking (line 56) | pub fn into_blocking(self) -> super::BlockingTestFlash<ACTIVE, DFU, STAT...
FILE: embassy-boot/src/test_flash/blocking.rs
type BlockingTestFlash (line 10) | pub struct BlockingTestFlash<ACTIVE, DFU, STATE>
function new (line 27) | pub fn new(config: BootLoaderConfig<ACTIVE, DFU, STATE>) -> Self {
function active (line 35) | pub fn active(&self) -> BlockingPartition<NoopRawMutex, ACTIVE> {
function dfu (line 39) | pub fn dfu(&self) -> BlockingPartition<NoopRawMutex, DFU> {
function state (line 43) | pub fn state(&self) -> BlockingPartition<NoopRawMutex, STATE> {
function create_partition (line 47) | pub fn create_partition<T: NorFlash>(
function into_async (line 60) | pub fn into_async(self) -> super::AsyncTestFlash<ACTIVE, DFU, STATE> {
FILE: embassy-embedded-hal/src/adapter/blocking_async.rs
type BlockingAsync (line 8) | pub struct BlockingAsync<T> {
function new (line 14) | pub fn new(wrapped: T) -> Self {
type Error (line 27) | type Error = E;
function read (line 35) | async fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Sel...
function write (line 39) | async fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self:...
function write_read (line 43) | async fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8...
function transaction (line 47) | async fn transaction(
type Error (line 65) | type Error = E;
function flush (line 73) | async fn flush(&mut self) -> Result<(), Self::Error> {
function write (line 77) | async fn write(&mut self, data: &[u8]) -> Result<(), Self::Error> {
function read (line 82) | async fn read(&mut self, data: &mut [u8]) -> Result<(), Self::Error> {
function transfer (line 87) | async fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<()...
function transfer_in_place (line 92) | async fn transfer_in_place(&mut self, data: &mut [u8]) -> Result<(), Sel...
type Error (line 108) | type Error = T::Error;
constant WRITE_SIZE (line 115) | const WRITE_SIZE: usize = <T as NorFlash>::WRITE_SIZE;
constant ERASE_SIZE (line 116) | const ERASE_SIZE: usize = <T as NorFlash>::ERASE_SIZE;
method write (line 118) | async fn write(&mut self, offset: u32, data: &[u8]) -> Result<(), Self::...
method erase (line 122) | async fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
constant READ_SIZE (line 131) | const READ_SIZE: usize = <T as ReadNorFlash>::READ_SIZE;
method read (line 132) | async fn read(&mut self, address: u32, data: &mut [u8]) -> Result<(), Se...
method capacity (line 136) | fn capacity(&self) -> usize {
FILE: embassy-embedded-hal/src/adapter/yielding_async.rs
type YieldingAsync (line 7) | pub struct YieldingAsync<T> {
function new (line 13) | pub fn new(wrapped: T) -> Self {
type Error (line 25) | type Error = T::Error;
function read (line 32) | async fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Sel...
function write (line 38) | async fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self:...
function write_read (line 44) | async fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8...
function transaction (line 50) | async fn transaction(
type Error (line 69) | type Error = T::Error;
function flush (line 76) | async fn flush(&mut self) -> Result<(), Self::Error> {
function write (line 82) | async fn write(&mut self, data: &[Word]) -> Result<(), Self::Error> {
function read (line 88) | async fn read(&mut self, data: &mut [Word]) -> Result<(), Self::Error> {
function transfer (line 94) | async fn transfer(&mut self, read: &mut [Word], write: &[Word]) -> Resul...
function transfer_in_place (line 100) | async fn transfer_in_place(&mut self, words: &mut [Word]) -> Result<(), ...
type Error (line 111) | type Error = T::Error;
constant READ_SIZE (line 117) | const READ_SIZE: usize = T::READ_SIZE;
function read (line 119) | async fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Se...
function capacity (line 124) | fn capacity(&self) -> usize {
constant WRITE_SIZE (line 130) | const WRITE_SIZE: usize = T::WRITE_SIZE;
constant ERASE_SIZE (line 131) | const ERASE_SIZE: usize = T::ERASE_SIZE;
function write (line 133) | async fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self:...
function erase (line 139) | async fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
function can_erase (line 163) | async fn can_erase() {
FILE: embassy-embedded-hal/src/flash/concat_flash.rs
type ConcatFlash (line 9) | pub struct ConcatFlash<First, Second>(First, Second);
function new (line 13) | pub fn new(first: First, second: Second) -> Self {
function get_read_size (line 18) | const fn get_read_size(first_read_size: usize, second_read_size: usize) ...
function get_write_size (line 25) | const fn get_write_size(first_write_size: usize, second_write_size: usiz...
function get_max_erase_size (line 32) | const fn get_max_erase_size(first_erase_size: usize, second_erase_size: ...
type Error (line 50) | type Error = E;
constant READ_SIZE (line 59) | const READ_SIZE: usize = get_read_size(First::READ_SIZE, Second::READ_SI...
method read (line 61) | fn read(&mut self, mut offset: u32, mut bytes: &mut [u8]) -> Result<(), ...
method capacity (line 76) | fn capacity(&self) -> usize {
constant WRITE_SIZE (line 87) | const WRITE_SIZE: usize = get_write_size(First::WRITE_SIZE, Second::WRIT...
constant ERASE_SIZE (line 88) | const ERASE_SIZE: usize = get_max_erase_size(First::ERASE_SIZE, Second::...
method write (line 90) | fn write(&mut self, mut offset: u32, mut bytes: &[u8]) -> Result<(), E> {
method erase (line 105) | fn erase(&mut self, mut from: u32, to: u32) -> Result<(), E> {
constant READ_SIZE (line 135) | const READ_SIZE: usize = get_read_size(First::READ_SIZE, Second::READ_SI...
method read (line 137) | async fn read(&mut self, mut offset: u32, mut bytes: &mut [u8]) -> Resul...
method capacity (line 152) | fn capacity(&self) -> usize {
constant WRITE_SIZE (line 163) | const WRITE_SIZE: usize = get_write_size(First::WRITE_SIZE, Second::WRIT...
constant ERASE_SIZE (line 164) | const ERASE_SIZE: usize = get_max_erase_size(First::ERASE_SIZE, Second::...
method write (line 166) | async fn write(&mut self, mut offset: u32, mut bytes: &[u8]) -> Result<(...
method erase (line 181) | async fn erase(&mut self, mut from: u32, to: u32) -> Result<(), E> {
function can_write_and_read_across_flashes (line 214) | fn can_write_and_read_across_flashes() {
function can_erase_across_flashes (line 231) | fn can_erase_across_flashes() {
FILE: embassy-embedded-hal/src/flash/mem_flash.rs
type MemFlash (line 8) | pub(crate) struct MemFlash<const SIZE: usize, const ERASE_SIZE: usize, c...
function new (line 16) | pub const fn new(fill: u8) -> Self {
function read (line 24) | fn read(&mut self, offset: u32, bytes: &mut [u8]) {
function write (line 29) | fn write(&mut self, offset: u32, bytes: &[u8]) {
function erase (line 39) | fn erase(&mut self, from: u32, to: u32) {
method default (line 52) | fn default() -> Self {
type Error (line 60) | type Error = core::convert::Infallible;
constant READ_SIZE (line 66) | const READ_SIZE: usize = 1;
method read (line 68) | fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Er...
method capacity (line 73) | fn capacity(&self) -> usize {
constant WRITE_SIZE (line 81) | const WRITE_SIZE: usize = WRITE_SIZE;
constant ERASE_SIZE (line 82) | const ERASE_SIZE: usize = ERASE_SIZE;
method write (line 84) | fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error> {
method erase (line 89) | fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
constant READ_SIZE (line 98) | const READ_SIZE: usize = 1;
method read (line 100) | async fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Se...
method capacity (line 105) | fn capacity(&self) -> usize {
constant WRITE_SIZE (line 113) | const WRITE_SIZE: usize = WRITE_SIZE;
constant ERASE_SIZE (line 114) | const ERASE_SIZE: usize = ERASE_SIZE;
method write (line 116) | async fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self:...
method erase (line 121) | async fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
FILE: embassy-embedded-hal/src/flash/partition/asynch.rs
type Partition (line 15) | pub struct Partition<'a, M: RawMutex, T: NorFlash> {
method clone (line 22) | fn clone(&self) -> Self {
function new (line 33) | pub const fn new(flash: &'a Mutex<M, T>, offset: u32, size: u32) -> Self {
function offset (line 45) | pub const fn offset(&self) -> u32 {
function size (line 50) | pub const fn size(&self) -> u32 {
type Error (line 56) | type Error = Error<T::Error>;
constant READ_SIZE (line 60) | const READ_SIZE: usize = T::READ_SIZE;
method read (line 62) | async fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Se...
method capacity (line 71) | fn capacity(&self) -> usize {
constant WRITE_SIZE (line 77) | const WRITE_SIZE: usize = T::WRITE_SIZE;
constant ERASE_SIZE (line 78) | const ERASE_SIZE: usize = T::ERASE_SIZE;
method write (line 80) | async fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self:...
method erase (line 89) | async fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
function can_read (line 112) | async fn can_read() {
function can_write (line 126) | async fn can_write() {
function can_erase (line 140) | async fn can_erase() {
FILE: embassy-embedded-hal/src/flash/partition/blocking.rs
type BlockingPartition (line 16) | pub struct BlockingPartition<'a, M: RawMutex, T: NorFlash> {
method clone (line 23) | fn clone(&self) -> Self {
function new (line 34) | pub const fn new(flash: &'a Mutex<M, RefCell<T>>, offset: u32, size: u32...
function offset (line 46) | pub const fn offset(&self) -> u32 {
function size (line 51) | pub const fn size(&self) -> u32 {
type Error (line 57) | type Error = Error<T::Error>;
constant READ_SIZE (line 61) | const READ_SIZE: usize = T::READ_SIZE;
method read (line 63) | fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Er...
method capacity (line 76) | fn capacity(&self) -> usize {
constant WRITE_SIZE (line 82) | const WRITE_SIZE: usize = T::WRITE_SIZE;
constant ERASE_SIZE (line 83) | const ERASE_SIZE: usize = T::ERASE_SIZE;
method write (line 85) | fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error> {
method erase (line 98) | fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
function can_read (line 122) | fn can_read() {
function can_write (line 136) | fn can_write() {
function can_erase (line 150) | fn can_erase() {
FILE: embassy-embedded-hal/src/flash/partition/mod.rs
type Error (line 14) | pub enum Error<T> {
method kind (line 22) | fn kind(&self) -> NorFlashErrorKind {
FILE: embassy-embedded-hal/src/lib.rs
type SetConfig (line 21) | pub trait SetConfig {
method set_config (line 29) | fn set_config(&mut self, config: &Self::Config) -> Result<(), Self::Co...
type GetConfig (line 33) | pub trait GetConfig {
method get_config (line 38) | fn get_config(&self) -> Self::Config;
FILE: embassy-embedded-hal/src/shared_bus/asynch/i2c.rs
type I2cDevice (line 33) | pub struct I2cDevice<'a, M: RawMutex, BUS> {
function new (line 39) | pub fn new(bus: &'a Mutex<M, BUS>) -> Self {
method clone (line 45) | fn clone(&self) -> Self {
type Error (line 54) | type Error = I2cDeviceError<BUS::Error>;
function read (line 62) | async fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), I2c...
function write (line 68) | async fn write(&mut self, address: u8, write: &[u8]) -> Result<(), I2cDe...
function write_read (line 74) | async fn write_read(
function transaction (line 87) | async fn transaction(
type I2cDeviceWithConfig (line 105) | pub struct I2cDeviceWithConfig<'a, M: RawMutex, BUS: SetConfig> {
function new (line 112) | pub fn new(bus: &'a Mutex<M, BUS>, config: BUS::Config) -> Self {
function set_config (line 117) | pub fn set_config(&mut self, config: BUS::Config) {
method clone (line 126) | fn clone(&self) -> Self {
type Error (line 140) | type Error = I2cDeviceError<BUS::Error>;
function read (line 148) | async fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), I...
function write (line 155) | async fn write(&mut self, address: u8, bytes: &[u8]) -> Result<(), I2cDe...
function write_read (line 162) | async fn write_read(
function transaction (line 176) | async fn transaction(&mut self, address: u8, operations: &mut [i2c::Oper...
FILE: embassy-embedded-hal/src/shared_bus/asynch/spi.rs
type SpiDevice (line 39) | pub struct SpiDevice<'a, M: RawMutex, BUS, CS> {
function new (line 46) | pub fn new(bus: &'a Mutex<M, BUS>, cs: CS) -> Self {
type Error (line 56) | type Error = SpiDeviceError<BUS::Error, CS::Error>;
function transaction (line 66) | async fn transaction(&mut self, operations: &mut [spi::Operation<'_, Wor...
type SpiDeviceWithConfig (line 128) | pub struct SpiDeviceWithConfig<'a, M: RawMutex, BUS: SetConfig, CS> {
function new (line 136) | pub fn new(bus: &'a Mutex<M, BUS>, cs: CS, config: BUS::Config) -> Self {
function set_config (line 141) | pub fn set_config(&mut self, config: BUS::Config) {
type Error (line 152) | type Error = SpiDeviceError<BUS::Error, CS::Error>;
function transaction (line 162) | async fn transaction(&mut self, operations: &mut [spi::Operation<'_, Wor...
FILE: embassy-embedded-hal/src/shared_bus/blocking/i2c.rs
type I2cDevice (line 28) | pub struct I2cDevice<'a, M: RawMutex, BUS> {
function new (line 34) | pub fn new(bus: &'a Mutex<M, RefCell<BUS>>) -> Self {
method clone (line 40) | fn clone(&self) -> Self {
type Error (line 49) | type Error = I2cDeviceError<BUS::Error>;
method read (line 57) | fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::E...
method write (line 62) | fn write(&mut self, address: u8, bytes: &[u8]) -> Result<(), Self::Error> {
method write_read (line 67) | fn write_read(&mut self, address: u8, wr_buffer: &[u8], rd_buffer: &mut ...
method transaction (line 75) | fn transaction<'a>(&mut self, address: u8, operations: &mut [Operation<'...
type Error (line 89) | type Error = I2cDeviceError<E>;
function write (line 91) | fn write(&mut self, addr: u8, bytes: &[u8]) -> Result<(), Self::Error> {
type Error (line 102) | type Error = I2cDeviceError<E>;
function read (line 104) | fn read(&mut self, addr: u8, bytes: &mut [u8]) -> Result<(), Self::Error> {
type Error (line 115) | type Error = I2cDeviceError<E>;
function write_read (line 117) | fn write_read<'w>(&mut self, addr: u8, bytes: &'w [u8], buffer: &'w mut ...
type I2cDeviceWithConfig (line 131) | pub struct I2cDeviceWithConfig<'a, M: RawMutex, BUS: SetConfig> {
function new (line 138) | pub fn new(bus: &'a Mutex<M, RefCell<BUS>>, config: BUS::Config) -> Self {
function set_config (line 143) | pub fn set_config(&mut self, config: BUS::Config) {
method clone (line 152) | fn clone(&self) -> Self {
type Error (line 165) | type Error = I2cDeviceError<BUS::Error>;
method read (line 173) | fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::E...
method write (line 181) | fn write(&mut self, address: u8, bytes: &[u8]) -> Result<(), Self::Error> {
method write_read (line 189) | fn write_read(&mut self, address: u8, wr_buffer: &[u8], rd_buffer: &mut ...
method transaction (line 198) | fn transaction<'a>(&mut self, address: u8, operations: &mut [Operation<'...
FILE: embassy-embedded-hal/src/shared_bus/blocking/spi.rs
type SpiDevice (line 31) | pub struct SpiDevice<'a, M: RawMutex, BUS, CS> {
function new (line 38) | pub fn new(bus: &'a Mutex<M, RefCell<BUS>>, cs: CS) -> Self {
type Error (line 48) | type Error = SpiDeviceError<BUS::Error, CS::Error>;
function transaction (line 58) | fn transaction(&mut self, operations: &mut [embedded_hal_1::spi::Operati...
type SpiDeviceWithConfig (line 99) | pub struct SpiDeviceWithConfig<'a, M: RawMutex, BUS: SetConfig, CS> {
function new (line 107) | pub fn new(bus: &'a Mutex<M, RefCell<BUS>>, cs: CS, config: BUS::Config)...
function set_config (line 112) | pub fn set_config(&mut self, config: BUS::Config) {
type Error (line 123) | type Error = SpiDeviceError<BUS::Error, CS::Error>;
function transaction (line 133) | fn transaction(&mut self, operations: &mut [embedded_hal_1::spi::Operati...
FILE: embassy-embedded-hal/src/shared_bus/mod.rs
type I2cDeviceError (line 12) | pub enum I2cDeviceError<BUS> {
function kind (line 23) | fn kind(&self) -> i2c::ErrorKind {
type SpiDeviceError (line 35) | pub enum SpiDeviceError<BUS, CS> {
function kind (line 51) | fn kind(&self) -> spi::ErrorKind {
FILE: embassy-executor-macros/src/lib.rs
function task (line 41) | pub fn task(args: TokenStream, item: TokenStream) -> TokenStream {
function main_avr (line 46) | pub fn main_avr(args: TokenStream, item: TokenStream) -> TokenStream {
function main_cortex_m (line 69) | pub fn main_cortex_m(args: TokenStream, item: TokenStream) -> TokenStream {
function main_cortex_ar (line 94) | pub fn main_cortex_ar(args: TokenStream, item: TokenStream) -> TokenStre...
function main_spin (line 119) | pub fn main_spin(args: TokenStream, item: TokenStream) -> TokenStream {
function main_riscv (line 152) | pub fn main_riscv(args: TokenStream, item: TokenStream) -> TokenStream {
function main_std (line 175) | pub fn main_std(args: TokenStream, item: TokenStream) -> TokenStream {
function main_wasm (line 198) | pub fn main_wasm(args: TokenStream, item: TokenStream) -> TokenStream {
function main_unspecified (line 222) | pub fn main_unspecified(args: TokenStream, item: TokenStream) -> TokenSt...
FILE: embassy-executor-macros/src/macros/main.rs
type Flavor (line 11) | enum Flavor {
type Arch (line 16) | pub(crate) struct Arch {
type Args (line 71) | struct Args {
function run (line 78) | pub fn run(args: TokenStream, item: TokenStream, arch: &Arch) -> TokenSt...
FILE: embassy-executor-macros/src/macros/task.rs
type Args (line 13) | struct Args {
function run (line 21) | pub fn run(args: TokenStream, item: TokenStream) -> TokenStream {
function check_arg_ty (line 261) | fn check_arg_ty(errors: &mut TokenStream, ty: &Type) {
FILE: embassy-executor-macros/src/util.rs
function token_stream_with_error (line 8) | pub fn token_stream_with_error(mut tokens: TokenStream, error: syn::Erro...
function error (line 13) | pub fn error<A: ToTokens, T: Display>(s: &mut TokenStream, obj: A, msg: ...
type ItemFn (line 23) | pub struct ItemFn {
method parse (line 32) | fn parse(input: ParseStream) -> syn::Result<Self> {
method to_tokens (line 66) | fn to_tokens(&self, tokens: &mut TokenStream) {
FILE: embassy-executor-timer-queue/src/lib.rs
constant ITEM_WORDS (line 25) | const ITEM_WORDS: usize = if cfg!(feature = "timer-item-size-8-words") {
type TimerQueueItem (line 41) | pub struct TimerQueueItem {
method new (line 47) | pub const fn new() -> Self {
method from_embassy_waker (line 62) | pub unsafe fn from_embassy_waker(waker: &Waker) -> &'static mut Self {
method as_ref (line 76) | pub unsafe fn as_ref<T>(&self) -> &T {
method as_mut (line 87) | pub unsafe fn as_mut<T>(&self) -> &mut T {
function validate (line 93) | const fn validate<T>() {
FILE: embassy-executor/build.rs
function main (line 4) | fn main() {
FILE: embassy-executor/build_common.rs
type CfgSet (line 15) | pub struct CfgSet {
method new (line 21) | pub fn new() -> Self {
method enable (line 32) | pub fn enable(&mut self, cfg: impl AsRef<str>) {
method enable_all (line 38) | pub fn enable_all(&mut self, cfgs: &[impl AsRef<str>]) {
method declare (line 47) | pub fn declare(&mut self, cfg: impl AsRef<str>) {
method declare_all (line 53) | pub fn declare_all(&mut self, cfgs: &[impl AsRef<str>]) {
method set (line 59) | pub fn set(&mut self, cfg: impl Into<String>, enable: bool) {
function set_target_cfgs (line 69) | pub fn set_target_cfgs(cfgs: &mut CfgSet) {
FILE: embassy-executor/gen_config.py
function feature (line 10) | def feature(name, default, min=None, max=None, pow2=None, vals=None, fac...
FILE: embassy-executor/src/fmt.rs
type NoneError (line 217) | pub struct NoneError;
type Try (line 219) | pub trait Try {
method into_result (line 222) | fn into_result(self) -> Result<Self::Ok, Self::Error>;
type Ok (line 226) | type Ok = T;
type Error (line 227) | type Error = NoneError;
method into_result (line 230) | fn into_result(self) -> Result<T, NoneError> {
type Ok (line 236) | type Ok = T;
type Error (line 237) | type Error = E;
method into_result (line 240) | fn into_result(self) -> Self {
type Bytes (line 245) | pub(crate) struct Bytes<'a>(pub &'a [u8]);
method fmt (line 248) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 254) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 260) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
function format (line 267) | fn format(&self, fmt: defmt::Formatter) {
FILE: embassy-executor/src/lib.rs
type TaskReturnValue (line 72) | trait TaskReturnValue {}
type TaskFn (line 81) | pub trait TaskFn<Args>: Copy {
type TaskPoolHolder (line 117) | pub struct TaskPoolHolder<const SIZE: usize, const ALIGN: usize>
function get (line 133) | pub const fn get(&self) -> *const u8 {
function task_pool_size (line 138) | pub const fn task_pool_size<F, Args, Fut, const POOL_SIZE: usize>(_: F) ...
function task_pool_align (line 146) | pub const fn task_pool_align<F, Args, Fut, const POOL_SIZE: usize>(_: F)...
function task_pool_new (line 154) | pub const fn task_pool_new<F, Args, Fut, const POOL_SIZE: usize>(_: F) -...
type Align (line 164) | pub struct Align<const N: usize>([<Self as Alignment>::Archetype; 0])
type Alignment (line 168) | trait Alignment {
type HasOutput (line 223) | pub trait HasOutput {
type Output (line 228) | type Output = O;
type Output (line 254) | type Output = O;
type Never (line 232) | pub type Never = <fn() -> ! as HasOutput>::Output;
type TaskReturnValue (line 244) | pub trait TaskReturnValue {}
type HasOutput (line 249) | pub trait HasOutput {
type Output (line 228) | type Output = O;
type Output (line 254) | type Output = O;
type Never (line 258) | pub type Never = <fn() -> ! as HasOutput>::Output;
FILE: embassy-executor/src/metadata.rs
type Metadata (line 16) | pub struct Metadata {
method new (line 26) | pub(crate) const fn new() -> Self {
method reset (line 39) | pub(crate) fn reset(&self) {
method for_current_task (line 58) | pub fn for_current_task() -> impl Future<Output = &'static Self> {
method name (line 66) | pub fn name(&self) -> Option<&'static str> {
method set_name (line 74) | pub fn set_name(&self, name: &'static str) {
method priority (line 80) | pub fn priority(&self) -> u8 {
method set_priority (line 86) | pub fn set_priority(&self, priority: u8) {
method deadline (line 92) | pub fn deadline(&self) -> u64 {
method set_deadline (line 100) | pub fn set_deadline(&self, instant_ticks: u64) {
method unset_deadline (line 107) | pub fn unset_deadline(&self) {
method set_deadline_after (line 116) | pub fn set_deadline_after(&self, duration_ticks: u64) {
method increment_deadline (line 138) | pub fn increment_deadline(&self, duration_ticks: u64) {
FILE: embassy-executor/src/platform/avr.rs
function __pender (line 18) | fn __pender(_context: *mut ()) {
type Executor (line 23) | pub struct Executor {
method new (line 30) | pub fn new() -> Self {
method run (line 55) | pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
FILE: embassy-executor/src/platform/cortex_ar.rs
function __pender (line 9) | fn __pender(context: *mut ()) {
constant THREAD_PENDER (line 25) | pub(super) const THREAD_PENDER: usize = usize::MAX;
type Executor (line 44) | pub struct Executor {
method new (line 51) | pub fn new() -> Self {
method run (line 76) | pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
FILE: embassy-executor/src/platform/cortex_m.rs
function __pender (line 3) | fn __pender(context: *mut ()) {
constant THREAD_PENDER (line 49) | pub(super) const THREAD_PENDER: usize = usize::MAX;
type Executor (line 68) | pub struct Executor {
method new (line 75) | pub fn new() -> Self {
method run (line 100) | pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
type InterruptExecutor (line 147) | pub struct InterruptExecutor {
method new (line 158) | pub const fn new() -> Self {
method on_interrupt (line 171) | pub unsafe fn on_interrupt(&'static self) {
method start (line 199) | pub fn start(&'static self, irq: impl InterruptNumber) -> crate::SendS...
method spawner (line 224) | pub fn spawner(&'static self) -> crate::SendSpawner {
FILE: embassy-executor/src/platform/riscv32.rs
function __pender (line 19) | fn __pender(_context: *mut ()) {
type Executor (line 24) | pub struct Executor {
method new (line 31) | pub fn new() -> Self {
method run (line 56) | pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
FILE: embassy-executor/src/platform/spin.rs
function __pender (line 15) | fn __pender(_context: *mut ()) {}
type Executor (line 18) | pub struct Executor {
method new (line 25) | pub fn new() -> Self {
method run (line 50) | pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
FILE: embassy-executor/src/platform/std.rs
function __pender (line 16) | fn __pender(context: *mut ()) {
type Executor (line 22) | pub struct Executor {
method new (line 30) | pub fn new() -> Self {
method run (line 57) | pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
method run_until (line 65) | pub fn run_until(&'static mut self, init: impl FnOnce(Spawner), mut do...
type Signaler (line 80) | struct Signaler {
method new (line 86) | fn new() -> Self {
method wait (line 93) | fn wait(&self) {
method signal (line 101) | fn signal(&self) {
FILE: embassy-executor/src/platform/wasm.rs
function __pender (line 19) | fn __pender(context: *mut ()) {
type WasmContext (line 24) | pub(crate) struct WasmContext {
method new (line 30) | pub fn new() -> Self {
type Executor (line 39) | pub struct Executor {
method new (line 47) | pub fn new() -> Self {
method start (line 72) | pub fn start(&'static mut self, init: impl FnOnce(Spawner)) {
FILE: embassy-executor/src/raw/deadline.rs
type Deadline (line 10) | pub(crate) struct Deadline {
method new (line 16) | pub(crate) const fn new(instant_ticks: u64) -> Self {
method new_unset (line 23) | pub(crate) const fn new_unset() -> Self {
method set (line 27) | pub(crate) fn set(&self, instant_ticks: u64) {
method instant_ticks (line 34) | pub(crate) fn instant_ticks(&self) -> u64 {
constant UNSET_TICKS (line 43) | pub(crate) const UNSET_TICKS: u64 = u64::MAX;
FILE: embassy-executor/src/raw/mod.rs
function __embassy_time_queue_item_from_waker (line 57) | extern "Rust" fn __embassy_time_queue_item_from_waker(waker: &Waker) -> ...
function __try_embassy_time_queue_item_from_waker (line 62) | extern "Rust" fn __try_embassy_time_queue_item_from_waker(waker: &Waker)...
type TaskHeader (line 105) | pub(crate) struct TaskHeader {
type TaskRef (line 123) | pub struct TaskRef {
method new (line 131) | fn new<F: Future + 'static>(task: &'static TaskStorage<F>) -> Self {
method from_ptr (line 138) | pub(crate) unsafe fn from_ptr(ptr: *const TaskHeader) -> Self {
method header (line 144) | pub(crate) fn header(self) -> &'static TaskHeader {
method metadata (line 148) | pub(crate) fn metadata(self) -> &'static Metadata {
method executor (line 153) | pub unsafe fn executor(self) -> Option<&'static Executor> {
method timer_queue_item (line 163) | pub unsafe fn timer_queue_item(mut self) -> &'static mut TimerQueueItem {
method as_ptr (line 168) | pub(crate) fn as_ptr(self) -> *const TaskHeader {
method id (line 174) | pub fn id(&self) -> u32 {
type TaskStorage (line 195) | pub struct TaskStorage<F: Future + 'static> {
function poll_exited (line 200) | unsafe fn poll_exited(_p: TaskRef) {
constant NEW (line 205) | const NEW: Self = Self::new();
function new (line 208) | pub const fn new() -> Self {
function spawn (line 239) | pub fn spawn(&'static self, future: impl FnOnce() -> F) -> Result<SpawnT...
function poll (line 247) | unsafe fn poll(p: TaskRef) {
function _assert_sync (line 283) | fn _assert_sync(self) {
type AvailableTask (line 291) | pub struct AvailableTask<F: Future + 'static> {
function claim (line 299) | pub fn claim(task: &'static TaskStorage<F>) -> Option<Self> {
function initialize_impl (line 303) | fn initialize_impl<S>(self, future: impl FnOnce() -> F) -> SpawnToken<S> {
function initialize (line 316) | pub fn initialize(self, future: impl FnOnce() -> F) -> SpawnToken<F> {
function __initialize_async_fn (line 327) | pub unsafe fn __initialize_async_fn<FutFn>(self, future: impl FnOnce() -...
type TaskPool (line 360) | pub struct TaskPool<F: Future + 'static, const N: usize> {
function new (line 366) | pub const fn new() -> Self {
function spawn_impl (line 372) | fn spawn_impl<T>(&'static self, future: impl FnOnce() -> F) -> Result<Sp...
function spawn (line 386) | pub fn spawn(&'static self, future: impl FnOnce() -> F) -> Result<SpawnT...
function _spawn_async_fn (line 399) | pub unsafe fn _spawn_async_fn<FutFn>(&'static self, future: FutFn) -> Re...
type Pender (line 409) | pub(crate) struct Pender(*mut ());
method pend (line 415) | pub(crate) fn pend(self) {
type SyncExecutor (line 423) | pub(crate) struct SyncExecutor {
method new (line 429) | pub(crate) fn new(pender: Pender) -> Self {
method enqueue (line 443) | unsafe fn enqueue(&self, task: TaskRef, l: state::Token) {
method spawn (line 452) | pub(super) unsafe fn spawn(&'static self, task: TaskRef) {
method poll (line 468) | pub(crate) unsafe fn poll(&'static self) {
type Executor (line 526) | pub struct Executor {
method wrap (line 533) | pub(crate) unsafe fn wrap(inner: &SyncExecutor) -> &Self {
method new (line 542) | pub fn new(context: *mut ()) -> Self {
method spawn (line 558) | pub(super) unsafe fn spawn(&'static self, task: TaskRef) {
method poll (line 579) | pub unsafe fn poll(&'static self) {
method spawner (line 587) | pub fn spawner(&'static self) -> super::Spawner {
method id (line 592) | pub fn id(&'static self) -> usize {
function wake_task (line 600) | pub fn wake_task(task: TaskRef) {
function wake_task_no_pend (line 614) | pub fn wake_task_no_pend(task: TaskRef) {
FILE: embassy-executor/src/raw/run_queue.rs
type TransferStack (line 9) | type TransferStack<T> = cordyceps::TransferStack<T>;
type TransferStack (line 12) | type TransferStack<T> = MutexTransferStack<T>;
type RunQueueItem (line 18) | pub(crate) type RunQueueItem = Links<TaskHeader>;
type Handle (line 25) | type Handle = TaskRef;
method into_ptr (line 28) | fn into_ptr(r: TaskRef) -> NonNull<TaskHeader> {
method from_ptr (line 33) | unsafe fn from_ptr(ptr: NonNull<TaskHeader>) -> TaskRef {
method links (line 39) | unsafe fn links(ptr: NonNull<TaskHeader>) -> NonNull<Links<TaskHeader>> {
type RunQueue (line 56) | pub(crate) struct RunQueue {
method new (line 61) | pub const fn new() -> Self {
method enqueue (line 73) | pub(crate) unsafe fn enqueue(&self, task: TaskRef, _tok: super::state:...
method dequeue_all (line 87) | pub(crate) fn dequeue_all(&self, on_task: impl Fn(TaskRef)) {
method dequeue_all (line 110) | pub(crate) fn dequeue_all(&self, on_task: impl Fn(TaskRef)) {
function run_dequeue (line 160) | fn run_dequeue(taskref: &TaskRef) {
function run_dequeue (line 167) | fn run_dequeue(taskref: &TaskRef) {
type MutexTransferStack (line 175) | struct MutexTransferStack<T: Linked<cordyceps::stack::Links<T>>> {
function new (line 181) | const fn new() -> Self {
function push_was_empty (line 188) | fn push_was_empty(&self, item: T::Handle, token: super::state::Token) ->...
function take_all (line 201) | fn take_all(&self) -> cordyceps::Stack<T> {
FILE: embassy-executor/src/raw/state_atomics.rs
type AtomicState (line 3) | type AtomicState = core::sync::atomic::AtomicU32;
type AtomicState (line 5) | type AtomicState = core::sync::atomic::AtomicU8;
type StateBits (line 8) | type StateBits = u32;
type StateBits (line 10) | type StateBits = u8;
type Token (line 15) | pub(crate) struct Token(());
function locked (line 20) | pub(crate) fn locked<R>(f: impl FnOnce(Token) -> R) -> R {
constant STATE_SPAWNED (line 25) | pub(crate) const STATE_SPAWNED: StateBits = 1 << 0;
constant STATE_RUN_QUEUED (line 27) | pub(crate) const STATE_RUN_QUEUED: StateBits = 1 << 1;
type State (line 29) | pub(crate) struct State {
method new (line 34) | pub const fn new() -> State {
method spawn (line 42) | pub fn spawn(&self) -> bool {
method despawn (line 50) | pub fn despawn(&self) {
method run_enqueue (line 57) | pub fn run_enqueue(&self, f: impl FnOnce(Token)) {
method run_dequeue (line 66) | pub fn run_dequeue(&self) {
FILE: embassy-executor/src/raw/state_atomics_arm.rs
type Token (line 4) | pub(crate) struct Token(());
function locked (line 9) | pub(crate) fn locked<R>(f: impl FnOnce(Token) -> R) -> R {
constant STATE_SPAWNED (line 14) | pub(crate) const STATE_SPAWNED: u32 = 1 << 0;
constant STATE_RUN_QUEUED (line 15) | pub(crate) const STATE_RUN_QUEUED: u32 = 1 << 8;
type State (line 18) | pub(crate) struct State {
method new (line 28) | pub const fn new() -> State {
method as_u32 (line 37) | fn as_u32(&self) -> &AtomicU32 {
method spawn (line 43) | pub fn spawn(&self) -> bool {
method despawn (line 60) | pub fn despawn(&self) {
method run_enqueue (line 68) | pub fn run_enqueue(&self, f: impl FnOnce(Token)) {
method run_dequeue (line 78) | pub fn run_dequeue(&self) {
FILE: embassy-executor/src/raw/state_critical_section.rs
type StateBits (line 7) | type StateBits = u8;
type StateBits (line 9) | type StateBits = usize;
constant STATE_SPAWNED (line 12) | pub(crate) const STATE_SPAWNED: StateBits = 1 << 0;
constant STATE_RUN_QUEUED (line 14) | pub(crate) const STATE_RUN_QUEUED: StateBits = 1 << 1;
type State (line 16) | pub(crate) struct State {
method new (line 21) | pub const fn new() -> State {
method update (line 27) | fn update<R>(&self, f: impl FnOnce(&mut StateBits) -> R) -> R {
method update_with_cs (line 31) | fn update_with_cs<R>(&self, cs: CriticalSection<'_>, f: impl FnOnce(&m...
method spawn (line 41) | pub fn spawn(&self) -> bool {
method despawn (line 54) | pub fn despawn(&self) {
method run_enqueue (line 61) | pub fn run_enqueue(&self, f: impl FnOnce(Token)) {
method run_dequeue (line 75) | pub fn run_dequeue(&self, cs: CriticalSection<'_>) {
FILE: embassy-executor/src/raw/trace.rs
type TaskTracker (line 107) | pub(crate) struct TaskTracker {
method new (line 116) | pub const fn new() -> Self {
method add (line 130) | pub fn add(&self, task: TaskRef) {
method for_each (line 157) | pub fn for_each<F>(&self, mut f: F)
function _embassy_trace_poll_start (line 177) | fn _embassy_trace_poll_start(executor_id: u32);
function _embassy_trace_task_new (line 184) | fn _embassy_trace_task_new(executor_id: u32, task_id: u32);
function _embassy_trace_task_end (line 188) | fn _embassy_trace_task_end(executor_id: u32, task_id: u32);
function _embassy_trace_task_exec_begin (line 196) | fn _embassy_trace_task_exec_begin(executor_id: u32, task_id: u32);
function _embassy_trace_task_exec_end (line 208) | fn _embassy_trace_task_exec_end(excutor_id: u32, task_id: u32);
function _embassy_trace_task_ready_begin (line 221) | fn _embassy_trace_task_ready_begin(executor_id: u32, task_id: u32);
function _embassy_trace_executor_idle (line 228) | fn _embassy_trace_executor_idle(executor_id: u32);
function poll_start (line 232) | pub(crate) fn poll_start(executor: &SyncExecutor) {
function task_new (line 240) | pub(crate) fn task_new(executor: &SyncExecutor, task: &TaskRef) {
function task_end (line 264) | pub(crate) fn task_end(executor: *const SyncExecutor, task: &TaskRef) {
function task_ready_begin (line 272) | pub(crate) fn task_ready_begin(executor: &SyncExecutor, task: &TaskRef) {
function task_exec_begin (line 282) | pub(crate) fn task_exec_begin(executor: &SyncExecutor, task: &TaskRef) {
function task_exec_end (line 292) | pub(crate) fn task_exec_end(executor: &SyncExecutor, task: &TaskRef) {
function executor_idle (line 302) | pub(crate) fn executor_idle(executor: &SyncExecutor) {
function get_all_active_tasks (line 320) | fn get_all_active_tasks() -> impl Iterator<Item = TaskRef> + 'static {
function with_all_active_tasks (line 349) | fn with_all_active_tasks<F>(f: F)
function task_list (line 358) | fn task_list() {
function time (line 369) | fn time() -> u64 {
FILE: embassy-executor/src/raw/util.rs
type UninitCell (line 5) | pub(crate) struct UninitCell<T>(MaybeUninit<UnsafeCell<T>>);
function uninit (line 7) | pub const fn uninit() -> Self {
function as_mut_ptr (line 11) | pub unsafe fn as_mut_ptr(&self) -> *mut T {
function as_mut (line 16) | pub unsafe fn as_mut(&self) -> &mut T {
function write_in_place (line 21) | pub unsafe fn write_in_place(&self, func: impl FnOnce() -> T) {
function drop_in_place (line 25) | pub unsafe fn drop_in_place(&self) {
type SyncUnsafeCell (line 33) | pub struct SyncUnsafeCell<T> {
function new (line 41) | pub const fn new(value: T) -> Self {
function set (line 47) | pub unsafe fn set(&self, value: T) {
function get (line 51) | pub unsafe fn get(&self) -> T
FILE: embassy-executor/src/raw/waker.rs
function clone (line 7) | unsafe fn clone(p: *const ()) -> RawWaker {
function wake (line 11) | unsafe fn wake(p: *const ()) {
function drop (line 15) | unsafe fn drop(_: *const ()) {
function from_task (line 19) | pub(crate) unsafe fn from_task(p: TaskRef) -> Waker {
function task_from_waker (line 34) | pub fn task_from_waker(waker: &Waker) -> TaskRef {
function try_task_from_waker (line 41) | pub(crate) fn try_task_from_waker(waker: &Waker) -> Option<TaskRef> {
FILE: embassy-executor/src/raw/waker_turbo.rs
function from_task (line 6) | pub(crate) unsafe fn from_task(p: TaskRef) -> Waker {
function task_from_waker (line 21) | pub fn task_from_waker(waker: &Waker) -> TaskRef {
function try_task_from_waker (line 28) | pub(crate) fn try_task_from_waker(waker: &Waker) -> Option<TaskRef> {
function _turbo_wake (line 34) | fn _turbo_wake(ptr: NonNull<()>) {
FILE: embassy-executor/src/spawner.rs
type SpawnToken (line 25) | pub struct SpawnToken<S> {
function new (line 31) | pub(crate) unsafe fn new(raw_task: raw::TaskRef) -> Self {
function id (line 40) | pub fn id(&self) -> u32 {
function metadata (line 46) | pub fn metadata(&self) -> &Metadata {
method drop (line 52) | fn drop(&mut self) {
type SpawnError (line 60) | pub enum SpawnError {
method fmt (line 70) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 76) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method format (line 88) | fn format(&self, f: defmt::Formatter) {
type Spawner (line 107) | pub struct Spawner {
method new (line 113) | pub(crate) fn new(executor: &'static raw::Executor) -> Self {
method for_current_executor (line 144) | pub unsafe fn for_current_executor() -> impl Future<Output = Self> {
method spawn (line 162) | pub fn spawn<S>(&self, token: SpawnToken<S>) {
method make_send (line 171) | pub fn make_send(&self) -> SendSpawner {
method executor_id (line 176) | pub fn executor_id(&self) -> usize {
type SendSpawner (line 189) | pub struct SendSpawner {
method new (line 194) | pub(crate) fn new(executor: &'static raw::SyncExecutor) -> Self {
method for_current_executor (line 206) | pub fn for_current_executor() -> impl Future<Output = Self> {
method spawn (line 223) | pub fn spawn<S: Send>(&self, token: SpawnToken<S>) {
FILE: embassy-executor/tests/test.rs
function __pender (line 13) | fn __pender(context: *mut ()) {
type Trace (line 21) | struct Trace {
method new (line 26) | fn new() -> Self {
method push (line 31) | fn push(&self, value: &'static str) {
method get (line 35) | fn get(&self) -> Vec<&'static str> {
function setup (line 40) | fn setup() -> (&'static Executor, Trace) {
function executor_noop (line 49) | fn executor_noop() {
function executor_task (line 56) | fn executor_task() {
function executor_task_rpit (line 83) | fn executor_task_rpit() {
function executor_task_self_wake (line 111) | fn executor_task_self_wake() {
function executor_task_self_wake_twice (line 141) | fn executor_task_self_wake_twice() {
function waking_after_completion_does_not_poll (line 175) | fn waking_after_completion_does_not_poll() {
function waking_with_old_waker_after_respawn (line 221) | fn waking_with_old_waker_after_respawn() {
function executor_task_cfg_args (line 307) | fn executor_task_cfg_args() {
function recursive_task (line 321) | fn recursive_task() {
function task_metadata (line 331) | fn task_metadata() {
FILE: embassy-executor/tests/ui.rs
function ui (line 3) | fn ui() {
FILE: embassy-executor/tests/ui/abi.rs
type Foo (line 3) | struct Foo<'a>(&'a ());
function task (line 6) | async extern "C" fn task() {}
function main (line 8) | fn main() {}
FILE: embassy-executor/tests/ui/bad_return.rs
type Foo (line 3) | struct Foo<'a>(&'a ());
function task (line 6) | async fn task() -> u32 {
function main (line 10) | fn main() {}
FILE: embassy-executor/tests/ui/bad_return_impl_future.rs
function task (line 5) | fn task() -> impl Future<Output = u32> {
function main (line 9) | fn main() {}
FILE: embassy-executor/tests/ui/bad_return_impl_future_nightly.rs
function task (line 5) | fn task() -> impl Future<Output = u32> {
function main (line 9) | fn main() {}
FILE: embassy-executor/tests/ui/generics.rs
type Foo (line 3) | struct Foo<'a>(&'a ());
function task (line 6) | async fn task<T: Sized>(_t: T) {}
function main (line 8) | fn main() {}
FILE: embassy-executor/tests/ui/impl_trait.rs
function foo (line 4) | async fn foo(_x: impl Sized) {}
function main (line 6) | fn main() {}
FILE: embassy-executor/tests/ui/impl_trait_nested.rs
type Foo (line 3) | struct Foo<T>(T);
function foo (line 6) | async fn foo(_x: Foo<impl Sized + 'static>) {}
function main (line 8) | fn main() {}
FILE: embassy-executor/tests/ui/impl_trait_static.rs
function foo (line 4) | async fn foo(_x: impl Sized + 'static) {}
function main (line 6) | fn main() {}
FILE: embassy-executor/tests/ui/nonstatic_ref_anon.rs
function foo (line 4) | async fn foo(_x: &'_ u32) {}
function main (line 6) | fn main() {}
FILE: embassy-executor/tests/ui/nonstatic_ref_anon_nested.rs
function foo (line 4) | async fn foo(_x: &'static &'_ u32) {}
function main (line 6) | fn main() {}
FILE: embassy-executor/tests/ui/nonstatic_ref_elided.rs
function foo (line 4) | async fn foo(_x: &u32) {}
function main (line 6) | fn main() {}
FILE: embassy-executor/tests/ui/nonstatic_ref_generic.rs
function foo (line 4) | async fn foo<'a>(_x: &'a u32) {}
function main (line 6) | fn main() {}
FILE: embassy-executor/tests/ui/nonstatic_struct_anon.rs
type Foo (line 3) | struct Foo<'a>(&'a ());
function task (line 6) | async fn task(_x: Foo<'_>) {}
function main (line 8) | fn main() {}
FILE: embassy-executor/tests/ui/nonstatic_struct_elided.rs
type Foo (line 3) | struct Foo<'a>(&'a ());
function task (line 6) | async fn task(_x: Foo) {}
function main (line 8) | fn main() {}
FILE: embassy-executor/tests/ui/nonstatic_struct_generic.rs
type Foo (line 3) | struct Foo<'a>(&'a ());
function task (line 6) | async fn task<'a>(_x: Foo<'a>) {}
function main (line 8) | fn main() {}
FILE: embassy-executor/tests/ui/not_async.rs
type Foo (line 3) | struct Foo<'a>(&'a ());
function task (line 6) | fn task() {}
function main (line 8) | fn main() {}
FILE: embassy-executor/tests/ui/return_impl_future_nonsend.rs
function task (line 8) | fn task() -> impl Future<Output = ()> {
function send_spawn (line 17) | fn send_spawn(s: SendSpawner) {
function main (line 21) | fn main() {}
FILE: embassy-executor/tests/ui/return_impl_send.rs
function task (line 4) | fn task() -> impl Send {}
function main (line 6) | fn main() {}
FILE: embassy-executor/tests/ui/return_impl_send_nightly.rs
function task (line 4) | fn task() -> impl Send {}
function main (line 6) | fn main() {}
FILE: embassy-executor/tests/ui/self.rs
type Foo (line 3) | struct Foo<'a>(&'a ());
function task (line 6) | async fn task(self) {}
function main (line 8) | fn main() {}
FILE: embassy-executor/tests/ui/self_ref.rs
type Foo (line 3) | struct Foo<'a>(&'a ());
function task (line 6) | async fn task(&mut self) {}
function main (line 8) | fn main() {}
FILE: embassy-executor/tests/ui/spawn_nonsend.rs
function task (line 6) | async fn task(non_send: *mut ()) {
function send_spawn (line 10) | fn send_spawn(s: SendSpawner) {
function main (line 14) | fn main() {}
FILE: embassy-executor/tests/ui/task_safety_attribute.rs
function safe (line 7) | async fn safe() {}
function not_safe (line 10) | async unsafe fn not_safe() {}
function pender (line 13) | fn pender(_: *mut ()) {
function main (line 18) | fn main() {
FILE: embassy-executor/tests/ui/type_error.rs
function task (line 4) | async fn task() {
function main (line 8) | fn main() {}
FILE: embassy-executor/tests/ui/unsafe_op_in_unsafe_task.rs
function task (line 5) | async unsafe fn task() {
function main (line 10) | fn main() {}
FILE: embassy-executor/tests/ui/where_clause.rs
type Foo (line 3) | struct Foo<'a>(&'a ());
function task (line 6) | async fn task()
function main (line 12) | fn main() {}
FILE: embassy-futures/src/block_on.rs
function block_on (line 21) | pub fn block_on<F: Future>(mut fut: F) -> F::Output {
function poll_once (line 36) | pub fn poll_once<F: Future>(mut fut: F) -> Poll<F::Output> {
FILE: embassy-futures/src/fmt.rs
type NoneError (line 217) | pub struct NoneError;
type Try (line 219) | pub trait Try {
method into_result (line 222) | fn into_result(self) -> Result<Self::Ok, Self::Error>;
type Ok (line 226) | type Ok = T;
type Error (line 227) | type Error = NoneError;
method into_result (line 230) | fn into_result(self) -> Result<T, NoneError> {
type Ok (line 236) | type Ok = T;
type Error (line 237) | type Error = E;
method into_result (line 240) | fn into_result(self) -> Self {
type Bytes (line 245) | pub(crate) struct Bytes<'a>(pub &'a [u8]);
method fmt (line 248) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 254) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 260) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
function format (line 267) | fn format(&self, fmt: defmt::Formatter) {
FILE: embassy-futures/src/join.rs
type MaybeDone (line 10) | enum MaybeDone<Fut: Future> {
function poll (line 21) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> bool {
function take_output (line 35) | fn take_output(&mut self) -> Fut::Output {
function join (line 142) | pub fn join<Fut1, Fut2>(future1: Fut1, future2: Fut2) -> Join<Fut1, Fut2>
function join3 (line 171) | pub fn join3<Fut1, Fut2, Fut3>(future1: Fut1, future2: Fut2, future3: Fu...
function join4 (line 202) | pub fn join4<Fut1, Fut2, Fut3, Fut4>(
function join5 (line 240) | pub fn join5<Fut1, Fut2, Fut3, Fut4, Fut5>(
type JoinArray (line 261) | pub struct JoinArray<Fut: Future, const N: usize> {
function fmt (line 270) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
type Output (line 276) | type Output = [Fut::Output; N];
method poll (line 277) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
function join_array (line 318) | pub fn join_array<Fut: Future, const N: usize>(futures: [Fut; N]) -> Joi...
FILE: embassy-futures/src/select.rs
type Either (line 10) | pub enum Either<A, B> {
function is_first (line 19) | pub fn is_first(&self) -> bool {
function is_second (line 24) | pub fn is_second(&self) -> bool {
function select (line 35) | pub fn select<A, B>(a: A, b: B) -> Select<A, B>
type Select (line 46) | pub struct Select<A, B> {
type Output (line 58) | type Output = Either<A::Output, B::Output>;
method poll (line 60) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
type Either3 (line 79) | pub enum Either3<A, B, C> {
function is_first (line 90) | pub fn is_first(&self) -> bool {
function is_second (line 95) | pub fn is_second(&self) -> bool {
function is_third (line 100) | pub fn is_third(&self) -> bool {
function select3 (line 106) | pub fn select3<A, B, C>(a: A, b: B, c: C) -> Select3<A, B, C>
type Select3 (line 118) | pub struct Select3<A, B, C> {
type Output (line 130) | type Output = Either3<A::Output, B::Output, C::Output>;
method poll (line 132) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
type Either4 (line 155) | pub enum Either4<A, B, C, D> {
function is_first (line 168) | pub fn is_first(&self) -> bool {
function is_second (line 173) | pub fn is_second(&self) -> bool {
function is_third (line 178) | pub fn is_third(&self) -> bool {
function is_fourth (line 183) | pub fn is_fourth(&self) -> bool {
function select4 (line 189) | pub fn select4<A, B, C, D>(a: A, b: B, c: C, d: D) -> Select4<A, B, C, D>
type Select4 (line 202) | pub struct Select4<A, B, C, D> {
type Output (line 216) | type Output = Either4<A::Output, B::Output, C::Output, D::Output>;
method poll (line 218) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
type Either5 (line 245) | pub enum Either5<A, B, C, D, E> {
function is_first (line 260) | pub fn is_first(&self) -> bool {
function is_second (line 265) | pub fn is_second(&self) -> bool {
function is_third (line 270) | pub fn is_third(&self) -> bool {
function is_fourth (line 275) | pub fn is_fourth(&self) -> bool {
function is_fifth (line 280) | pub fn is_fifth(&self) -> bool {
function select5 (line 286) | pub fn select5<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E) -> Select5<A...
type Select5 (line 300) | pub struct Select5<A, B, C, D, E> {
type Output (line 316) | type Output = Either5<A::Output, B::Output, C::Output, D::Output, E::Out...
method poll (line 318) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
type Either6 (line 349) | pub enum Either6<A, B, C, D, E, F> {
function is_first (line 366) | pub fn is_first(&self) -> bool {
function is_second (line 371) | pub fn is_second(&self) -> bool {
function is_third (line 376) | pub fn is_third(&self) -> bool {
function is_fourth (line 381) | pub fn is_fourth(&self) -> bool {
function is_fifth (line 386) | pub fn is_fifth(&self) -> bool {
function is_sixth (line 391) | pub fn is_sixth(&self) -> bool {
function select6 (line 397) | pub fn select6<A, B, C, D, E, F>(a: A, b: B, c: C, d: D, e: E, f: F) -> ...
type Select6 (line 412) | pub struct Select6<A, B, C, D, E, F> {
type Output (line 430) | type Output = Either6<A::Output, B::Output, C::Output, D::Output, E::Out...
method poll (line 432) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
type SelectArray (line 467) | pub struct SelectArray<Fut, const N: usize> {
function select_array (line 478) | pub fn select_array<Fut: Future, const N: usize>(arr: [Fut; N]) -> Selec...
type Output (line 483) | type Output = (Fut::Output, usize);
method poll (line 485) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
type SelectSlice (line 512) | pub struct SelectSlice<'a, Fut> {
function select_slice (line 523) | pub fn select_slice<'a, Fut: Future>(slice: Pin<&'a mut [Fut]>) -> Selec...
type Output (line 528) | type Output = (Fut::Output, usize);
method poll (line 530) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
FILE: embassy-futures/src/yield_now.rs
function yield_now (line 29) | pub fn yield_now() -> impl Future<Output = ()> {
type YieldNowFuture (line 34) | struct YieldNowFuture {
type Output (line 39) | type Output = ();
method poll (line 40) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
FILE: embassy-hal-internal/build.rs
function main (line 4) | fn main() {
FILE: embassy-hal-internal/build_common.rs
type CfgSet (line 15) | pub struct CfgSet {
method new (line 21) | pub fn new() -> Self {
method enable (line 32) | pub fn enable(&mut self, cfg: impl AsRef<str>) {
method enable_all (line 38) | pub fn enable_all(&mut self, cfgs: &[impl AsRef<str>]) {
method declare (line 47) | pub fn declare(&mut self, cfg: impl AsRef<str>) {
method declare_all (line 53) | pub fn declare_all(&mut self, cfgs: &[impl AsRef<str>]) {
method set (line 59) | pub fn set(&mut self, cfg: impl Into<String>, enable: bool) {
function set_target_cfgs (line 69) | pub fn set_target_cfgs(cfgs: &mut CfgSet) {
FILE: embassy-hal-internal/src/atomic_ring_buffer.rs
type RingBuffer (line 17) | pub struct RingBuffer {
method new (line 43) | pub const fn new() -> Self {
method init (line 57) | pub unsafe fn init(&self, buf: *mut u8, len: usize) {
method deinit (line 73) | pub unsafe fn deinit(&self) {
method reader (line 88) | pub unsafe fn reader(&self) -> Reader<'_> {
method try_reader (line 97) | pub unsafe fn try_reader(&self) -> Option<Reader<'_>> {
method writer (line 110) | pub unsafe fn writer(&self) -> Writer<'_> {
method try_writer (line 119) | pub unsafe fn try_writer(&self) -> Option<Writer<'_>> {
method is_available (line 127) | pub fn is_available(&self) -> bool {
method len (line 132) | pub fn len(&self) -> usize {
method available (line 137) | pub fn available(&self) -> usize {
method is_full (line 149) | pub fn is_full(&self) -> bool {
method is_half_full (line 158) | pub fn is_half_full(&self) -> bool {
method is_empty (line 163) | pub fn is_empty(&self) -> bool {
method wrap (line 170) | fn wrap(&self, mut n: usize) -> usize {
type Reader (line 36) | pub struct Reader<'a>(&'a RingBuffer);
type Writer (line 39) | pub struct Writer<'a>(&'a RingBuffer);
function push (line 185) | pub fn push(&mut self, f: impl FnOnce(&mut [u8]) -> usize) -> usize {
function push_one (line 196) | pub fn push_one(&mut self, val: u8) -> bool {
function push_slice (line 210) | pub fn push_slice(&mut self) -> &mut [u8] {
function push_slices (line 218) | pub fn push_slices(&mut self) -> [&mut [u8]; 2] {
function push_buf (line 234) | pub fn push_buf(&mut self) -> (*mut u8, usize) {
function push_bufs (line 273) | pub fn push_bufs(&mut self) -> [(*mut u8, usize); 2] {
function push_done (line 301) | pub fn push_done(&mut self, n: usize) {
function pop (line 318) | pub fn pop(&mut self, f: impl FnOnce(&[u8]) -> usize) -> usize {
function pop_one (line 329) | pub fn pop_one(&mut self) -> Option<u8> {
function pop_slice (line 344) | pub fn pop_slice(&mut self) -> &mut [u8] {
function pop_buf (line 360) | pub fn pop_buf(&mut self) -> (*mut u8, usize) {
function pop_done (line 387) | pub fn pop_done(&mut self, n: usize) {
function push_pop (line 407) | fn push_pop() {
function zero_len (line 523) | fn zero_len() {
function push_slices (line 547) | fn push_slices() {
FILE: embassy-hal-internal/src/drop.rs
type OnDrop (line 7) | pub struct OnDrop<F: FnOnce()> {
function new (line 13) | pub fn new(f: F) -> Self {
function defuse (line 18) | pub fn defuse(self) {
method drop (line 24) | fn drop(&mut self) {
type DropBomb (line 36) | pub struct DropBomb {
method new (line 42) | pub fn new() -> Self {
method defuse (line 47) | pub fn defuse(self) {
method drop (line 53) | fn drop(&mut self) {
FILE: embassy-hal-internal/src/fmt.rs
type NoneError (line 217) | pub struct NoneError;
type Try (line 219) | pub trait Try {
method into_result (line 222) | fn into_result(self) -> Result<Self::Ok, Self::Error>;
type Ok (line 226) | type Ok = T;
type Error (line 227) | type Error = NoneError;
method into_result (line 230) | fn into_result(self) -> Result<T, NoneError> {
type Ok (line 236) | type Ok = T;
type Error (line 237) | type Error = E;
method into_result (line 240) | fn into_result(self) -> Self {
type Bytes (line 245) | pub(crate) struct Bytes<'a>(pub &'a [u8]);
method fmt (line 248) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 254) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 260) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
function format (line 267) | fn format(&self, fmt: defmt::Formatter) {
FILE: embassy-hal-internal/src/interrupt.rs
type InterruptExt (line 148) | pub unsafe trait InterruptExt: InterruptNumber + Copy {
method enable (line 151) | unsafe fn enable(self) {
method disable (line 158) | fn disable(self) {
method is_active (line 166) | fn is_active(self) -> bool {
method is_enabled (line 172) | fn is_enabled(self) -> bool {
method is_pending (line 178) | fn is_pending(self) -> bool {
method pend (line 184) | fn pend(self) {
method unpend (line 190) | fn unpend(self) {
method get_priority (line 196) | fn get_priority(self) -> Priority {
method set_priority (line 202) | fn set_priority(self, prio: Priority) {
method set_priority_with_cs (line 221) | fn set_priority_with_cs(self, _cs: CriticalSection, prio: Priority) {
function from (line 238) | fn from(p: Priority) -> Self {
constant PRIO_MASK (line 244) | const PRIO_MASK: u8 = 0x00;
constant PRIO_MASK (line 246) | const PRIO_MASK: u8 = 0x80;
constant PRIO_MASK (line 248) | const PRIO_MASK: u8 = 0xc0;
constant PRIO_MASK (line 250) | const PRIO_MASK: u8 = 0xe0;
constant PRIO_MASK (line 252) | const PRIO_MASK: u8 = 0xf0;
constant PRIO_MASK (line 254) | const PRIO_MASK: u8 = 0xf8;
constant PRIO_MASK (line 256) | const PRIO_MASK: u8 = 0xfc;
constant PRIO_MASK (line 258) | const PRIO_MASK: u8 = 0xfe;
constant PRIO_MASK (line 260) | const PRIO_MASK: u8 = 0xff;
type Priority (line 270) | pub enum Priority {
method from (line 232) | fn from(priority: u8) -> Self {
type Priority (line 282) | pub enum Priority {
method from (line 232) | fn from(priority: u8) -> Self {
type Priority (line 295) | pub enum Priority {
method from (line 232) | fn from(priority: u8) -> Self {
type Priority (line 310) | pub enum Priority {
method from (line 232) | fn from(priority: u8) -> Self {
type Priority (line 329) | pub enum Priority {
method from (line 232) | fn from(priority: u8) -> Self {
type Priority (line 356) | pub enum Priority {
method from (line 232) | fn from(priority: u8) -> Self {
type Priority (line 399) | pub enum Priority {
method from (line 232) | fn from(priority: u8) -> Self {
type Priority (line 474) | pub enum Priority {
method from (line 232) | fn from(priority: u8) -> Self {
type Priority (line 613) | pub enum Priority {
method from (line 232) | fn from(priority: u8) -> Self {
FILE: embassy-hal-internal/src/peripheral.rs
type Peri (line 17) | pub struct Peri<'a, T: PeripheralType> {
function new_unchecked (line 31) | pub const unsafe fn new_unchecked(inner: T) -> Self {
function clone_unchecked (line 49) | pub const unsafe fn clone_unchecked(&self) -> Peri<'a, T> {
function reborrow (line 56) | pub const fn reborrow(&mut self) -> Peri<'_, T> {
function into (line 69) | pub fn into<U>(self) -> Peri<'a, U>
type Target (line 79) | type Target = T;
method deref (line 82) | fn deref(&self) -> &Self::Target {
function fmt (line 88) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
function fmt (line 94) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
function format (line 101) | fn format(&self, fmt: defmt::Formatter) {
type PeripheralType (line 107) | pub trait PeripheralType: Copy + Sized {}
FILE: embassy-hal-internal/src/ratio.rs
type Ratio (line 9) | pub struct Ratio<T> {
function new_raw (line 19) | pub const fn new_raw(numer: T, denom: T) -> Ratio<T> {
function numer (line 25) | pub const fn numer(&self) -> &T {
function denom (line 31) | pub const fn denom(&self) -> &T {
function to_integer (line 39) | pub fn to_integer(&self) -> T {
type Output (line 45) | type Output = Self;
function div (line 48) | fn div(mut self, rhs: T) -> Self::Output {
type Output (line 55) | type Output = Self;
function mul (line 58) | fn mul(mut self, rhs: T) -> Self::Output {
type Output (line 65) | type Output = Self;
function add (line 68) | fn add(mut self, rhs: T) -> Self::Output {
function fmt (line 104) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
function basics (line 114) | fn basics() {
FILE: embassy-imxrt/src/clocks.rs
type Clocks (line 11) | pub enum Clocks {
method from (line 290) | fn from(value: MainPllClkSrc) -> Self {
method from (line 372) | fn from(value: MainClkSrc) -> Self {
type ClockConfig (line 37) | pub struct ClockConfig {
method crystal (line 65) | pub fn crystal() -> Self {
type State (line 125) | pub enum State {
type LposcFreq (line 135) | pub enum LposcFreq {
type Error (line 152) | type Error = ClockError;
method try_from (line 153) | fn try_from(value: u32) -> Result<Self, Self::Error> {
function from (line 143) | fn from(value: LposcFreq) -> Self {
type LposcConfig (line 163) | pub struct LposcConfig {
method init_lposc (line 460) | fn init_lposc() {
constant SFRO_FREQ (line 169) | const SFRO_FREQ: u32 = 16_000_000;
type SfroConfig (line 171) | pub struct SfroConfig {
type RtcFreq (line 176) | pub enum RtcFreq {
type Error (line 196) | type Error = ClockError;
method try_from (line 197) | fn try_from(value: u32) -> Result<Self, Self::Error> {
function from (line 186) | fn from(value: RtcFreq) -> Self {
type RtcInterrupts (line 208) | pub enum RtcInterrupts {
function from (line 218) | fn from(value: RtcInterrupts) -> Self {
type RtcClkConfig (line 227) | pub struct RtcClkConfig {
method init_rtc_clk (line 1136) | fn init_rtc_clk() {
type FfroFreq (line 241) | pub enum FfroFreq {
type Error (line 266) | type Error = ClockError;
method try_from (line 267) | fn try_from(value: u32) -> Result<Self, Self::Error> {
type FfroConfig (line 249) | pub struct FfroConfig {
method init_ffro_clk (line 514) | pub fn init_ffro_clk() {
function from (line 257) | fn from(value: FfroFreq) -> Self {
type MainPllClkSrc (line 279) | pub enum MainPllClkSrc {
type Error (line 300) | type Error = ClockError;
method try_from (line 301) | fn try_from(value: Clocks) -> Result<Self, Self::Error> {
type MainPllClkConfig (line 312) | pub struct MainPllClkConfig {
method calc_mult (line 838) | pub(self) fn calc_mult(rate: u32, base_freq: u32) -> Result<u8, ClockE...
method init_syspll (line 851) | pub(self) fn init_syspll() {
method init_syspll_pfd2 (line 887) | pub(self) fn init_syspll_pfd2(config_bits: u8) {
method init_syspll_pfd0 (line 913) | pub(self) fn init_syspll_pfd0(config_bits: u8) {
type ClkInConfig (line 338) | pub struct ClkInConfig {
type HclkConfig (line 346) | pub struct HclkConfig {
type MainClkSrc (line 354) | pub enum MainClkSrc {
type Error (line 386) | type Error = ClockError;
method try_from (line 387) | fn try_from(value: Clocks) -> Result<Self, Self::Error> {
type MainClkConfig (line 401) | pub struct MainClkConfig {
method init_main_clk (line 938) | fn init_main_clk() {
type SysClkConfig (line 413) | pub struct SysClkConfig {
method update_sys_core_clock (line 1221) | fn update_sys_core_clock(&self) {}
type SysOscConfig (line 420) | pub struct SysOscConfig {
constant SYS_OSC_DEFAULT_FREQ (line 424) | const SYS_OSC_DEFAULT_FREQ: u32 = 24_000_000;
type ClockError (line 429) | pub enum ClockError {
type ConfigurableClock (line 445) | pub trait ConfigurableClock {
method disable (line 447) | fn disable(&self) -> Result<(), ClockError>;
method enable_and_reset (line 449) | fn enable_and_reset(&self) -> Result<(), ClockError>;
method get_clock_rate (line 451) | fn get_clock_rate(&self) -> Result<u32, ClockError>;
method set_clock_rate (line 453) | fn set_clock_rate(&mut self, div: u8, mult: u8, freq: u32) -> Result<(...
method is_enabled (line 455) | fn is_enabled(&self) -> bool;
method enable_and_reset (line 474) | fn enable_and_reset(&self) -> Result<(), ClockError> {
method disable (line 478) | fn disable(&self) -> Result<(), ClockError> {
method get_clock_rate (line 486) | fn get_clock_rate(&self) -> Result<u32, ClockError> {
method set_clock_rate (line 489) | fn set_clock_rate(&mut self, _div: u8, _mult: u8, freq: u32) -> Result...
method is_enabled (line 507) | fn is_enabled(&self) -> bool {
method enable_and_reset (line 533) | fn enable_and_reset(&self) -> Result<(), ClockError> {
method disable (line 539) | fn disable(&self) -> Result<(), ClockError> {
method get_clock_rate (line 548) | fn get_clock_rate(&self) -> Result<u32, ClockError> {
method set_clock_rate (line 551) | fn set_clock_rate(&mut self, _div: u8, _mult: u8, freq: u32) -> Result...
method is_enabled (line 582) | fn is_enabled(&self) -> bool {
method enable_and_reset (line 588) | fn enable_and_reset(&self) -> Result<(), ClockError> {
method disable (line 596) | fn disable(&self) -> Result<(), ClockError> {
method get_clock_rate (line 605) | fn get_clock_rate(&self) -> Result<u32, ClockError> {
method set_clock_rate (line 612) | fn set_clock_rate(&mut self, _div: u8, _mult: u8, freq: u32) -> Result...
method is_enabled (line 623) | fn is_enabled(&self) -> bool {
method enable_and_reset (line 690) | fn enable_and_reset(&self) -> Result<(), ClockError> {
method disable (line 698) | fn disable(&self) -> Result<(), ClockError> {
method get_clock_rate (line 705) | fn get_clock_rate(&self) -> Result<u32, ClockError> {
method set_clock_rate (line 713) | fn set_clock_rate(&mut self, div: u8, mult: u8, freq: u32) -> Result<(...
method is_enabled (line 831) | fn is_enabled(&self) -> bool {
method enable_and_reset (line 1090) | fn enable_and_reset(&self) -> Result<(), ClockError> {
method disable (line 1094) | fn disable(&self) -> Result<(), ClockError> {
method get_clock_rate (line 1097) | fn get_clock_rate(&self) -> Result<u32, ClockError> {
method set_clock_rate (line 1101) | fn set_clock_rate(&mut self, _div: u8, _mult: u8, _freq: u32) -> Resul...
method is_enabled (line 1104) | fn is_enabled(&self) -> bool {
method enable_and_reset (line 1110) | fn enable_and_reset(&self) -> Result<(), ClockError> {
method disable (line 1114) | fn disable(&self) -> Result<(), ClockError> {
method get_clock_rate (line 1118) | fn get_clock_rate(&self) -> Result<u32, ClockError> {
method set_clock_rate (line 1125) | fn set_clock_rate(&mut self, _div: u8, _mult: u8, freq: u32) -> Result...
method is_enabled (line 1129) | fn is_enabled(&self) -> bool {
method enable_and_reset (line 1162) | fn enable_and_reset(&self) -> Result<(), ClockError> {
method disable (line 1167) | fn disable(&self) -> Result<(), ClockError> {
method set_clock_rate (line 1170) | fn set_clock_rate(&mut self, _div: u8, _mult: u8, freq: u32) -> Result...
method get_clock_rate (line 1203) | fn get_clock_rate(&self) -> Result<u32, ClockError> {
method is_enabled (line 1214) | fn is_enabled(&self) -> bool {
method enable_and_reset (line 1225) | fn enable_and_reset(&self) -> Result<(), ClockError> {
method disable (line 1249) | fn disable(&self) -> Result<(), ClockError> {
method get_clock_rate (line 1262) | fn get_clock_rate(&self) -> Result<u32, ClockError> {
method is_enabled (line 1269) | fn is_enabled(&self) -> bool {
method set_clock_rate (line 1272) | fn set_clock_rate(&mut self, _div: u8, _mult: u8, _freq: u32) -> Resul...
type MultiSourceClock (line 629) | pub trait MultiSourceClock {
method get_clock_source_and_rate (line 631) | fn get_clock_source_and_rate(&self, clock: &Clocks) -> Result<(Clocks,...
method set_clock_source_and_rate (line 633) | fn set_clock_source_and_rate(
method get_clock_source_and_rate (line 642) | fn get_clock_source_and_rate(&self, clock: &Clocks) -> Result<(Clocks,...
method set_clock_source_and_rate (line 651) | fn set_clock_source_and_rate(
method get_clock_source_and_rate (line 964) | fn get_clock_source_and_rate(&self, clock: &Clocks) -> Result<(Clocks,...
method set_clock_source_and_rate (line 990) | fn set_clock_source_and_rate(
function delay_loop_clocks (line 1278) | pub fn delay_loop_clocks(usec: u64, freq_mhz: u64) {
function set_pad_voltage_range (line 1288) | fn set_pad_voltage_range() {
function init_syscpuahb_clk (line 1306) | fn init_syscpuahb_clk() {
type ClockOutConfig (line 1317) | pub struct ClockOutConfig {
method default_config (line 1359) | pub fn default_config() -> Self {
method enable_and_reset (line 1367) | pub fn enable_and_reset(&mut self) -> Result<(), ClockError> {
method disable (line 1373) | pub fn disable(&mut self) -> Result<(), ClockError> {
method set_clkout_source (line 1379) | fn set_clkout_source(&mut self, src: ClkOutSrc) -> Result<(), ClockErr...
method set_clkout_divider (line 1444) | pub fn set_clkout_divider(&self, div: u8) -> Result<(), ClockError> {
method set_clkout_source_and_div (line 1456) | pub fn set_clkout_source_and_div(&mut self, src: ClkOutSrc, div: u8) -...
type ClkOutSrc (line 1326) | pub enum ClkOutSrc {
function init_clock_hw (line 1466) | fn init_clock_hw(config: ClockConfig) -> Result<(), ClockError> {
function init (line 1514) | pub(crate) unsafe fn init(config: ClockConfig) -> Result<(), ClockError> {
type SealedSysconPeripheral (line 1523) | trait SealedSysconPeripheral {
method enable_perph_clock (line 1524) | fn enable_perph_clock();
method reset_perph (line 1525) | fn reset_perph();
method disable_perph_clock (line 1526) | fn disable_perph_clock();
type SysconPeripheral (line 1531) | pub trait SysconPeripheral: SealedSysconPeripheral + 'static {}
function enable_and_reset (line 1537) | pub fn enable_and_reset<T: SysconPeripheral>() {
function enable (line 1543) | pub fn enable<T: SysconPeripheral>() {
function reset (line 1548) | pub fn reset<T: SysconPeripheral>() {
function disable (line 1557) | pub fn disable<T: SysconPeripheral>() {
FILE: embassy-imxrt/src/crc.rs
type Crc (line 10) | pub struct Crc<'d> {
type Config (line 17) | pub struct Config {
method new (line 40) | pub fn new(
method default (line 60) | fn default() -> Self {
function new (line 74) | pub fn new<T: Instance>(_peripheral: Peri<'d, T>, config: Config) -> Self {
function reconfigure (line 89) | fn reconfigure(&mut self) {
function feed_byte (line 111) | pub fn feed_byte(&mut self, byte: u8) -> u32 {
function feed_bytes (line 118) | pub fn feed_bytes(&mut self, bytes: &[u8]) -> u32 {
function feed_halfword (line 137) | pub fn feed_halfword(&mut self, halfword: u16) -> u32 {
function feed_halfwords (line 144) | pub fn feed_halfwords(&mut self, halfwords: &[u16]) -> u32 {
function feed_word (line 153) | pub fn feed_word(&mut self, word: u32) -> u32 {
function feed_words (line 160) | pub fn feed_words(&mut self, words: &[u32]) -> u32 {
type Info (line 169) | struct Info {
type SealedInstance (line 173) | trait SealedInstance {
method info (line 174) | fn info() -> Info;
method info (line 184) | fn info() -> Info {
type Instance (line 179) | pub trait Instance: SealedInstance + PeripheralType + SysconPeripheral +...
FILE: embassy-imxrt/src/dma.rs
constant MAX_CHUNK_SIZE (line 19) | pub(crate) const MAX_CHUNK_SIZE: usize = 1024;
function DMA0 (line 23) | fn DMA0() {
function init (line 47) | pub(crate) unsafe fn init() {
function read (line 73) | pub unsafe fn read<'a, C: Channel, W: Word>(ch: Peri<'a, C>, from: *cons...
function write (line 91) | pub unsafe fn write<'a, C: Channel, W: Word>(ch: Peri<'a, C>, from: *con...
function copy (line 109) | pub unsafe fn copy<'a, C: Channel, W: Word>(ch: Peri<'a, C>, from: &[W],...
function copy_inner (line 128) | fn copy_inner<'a, C: Channel>(
type Transfer (line 202) | pub struct Transfer<'a, C: Channel> {
function new (line 207) | pub(crate) fn new(channel: Peri<'a, C>) -> Self {
function abort (line 211) | pub(crate) fn abort(&mut self) -> usize {
method drop (line 242) | fn drop(&mut self) {
type Output (line 249) | type Output = ();
method poll (line 251) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
type Descriptor (line 267) | struct Descriptor {
method new (line 275) | const fn new() -> Self {
type Descriptors (line 286) | struct Descriptors {
method new (line 291) | const fn new() -> Self {
constant CHANNEL_COUNT (line 300) | pub(crate) const CHANNEL_COUNT: usize = 33;
type Channel (line 304) | pub trait Channel: PeripheralType + Sealed + Into<AnyChannel> + Sized + ...
method number (line 306) | fn number(&self) -> u8;
method regs (line 309) | fn regs(&self) -> &'static pac::dma0::RegisterBlock {
method number (line 366) | fn number(&self) -> u8 {
type Word (line 316) | pub trait Word: Sealed {
method width (line 318) | fn width() -> Width;
method size (line 321) | fn size() -> isize;
method width (line 326) | fn width() -> Width {
method size (line 330) | fn size() -> isize {
method width (line 337) | fn width() -> Width {
method size (line 341) | fn size() -> isize {
method width (line 348) | fn width() -> Width {
method size (line 352) | fn size() -> isize {
type AnyChannel (line 358) | pub struct AnyChannel {
FILE: embassy-imxrt/src/flexcomm/mod.rs
type Clock (line 16) | pub enum Clock {
type Sealed (line 48) | pub trait Sealed {}
type FlexcommLowLevel (line 52) | pub(crate) trait FlexcommLowLevel: sealed::Sealed + PeripheralType + Sys...
method reg (line 54) | fn reg() -> &'static pac::flexcomm0::RegisterBlock;
method enable (line 57) | fn enable(clk: Clock);
method reg (line 122) | fn reg() -> &'static crate::pac::flexcomm0::RegisterBlock {
method enable (line 128) | fn enable(clk: Clock) {
method reg (line 165) | fn reg() -> &'static crate::pac::flexcomm0::RegisterBlock {
method enable (line 171) | fn enable(clk: Clock) {
FILE: embassy-imxrt/src/flexcomm/spi.rs
type IoMode (line 22) | pub trait IoMode: sealed::Sealed {}
type Blocking (line 25) | pub struct Blocking;
type Async (line 30) | pub struct Async;
type Error (line 38) | pub enum Error {
method kind (line 948) | fn kind(&self) -> embedded_hal_1::spi::ErrorKind {
type Spi (line 43) | pub struct Spi<'a, M: IoMode> {
function new_blocking (line 50) | pub fn new_blocking<T: Instance>(
function new_blocking_txonly (line 65) | pub fn new_blocking_txonly<T: Instance>(
function new_blocking_rxonly (line 78) | pub fn new_blocking_rxonly<T: Instance>(
function new_blocking_loopback (line 94) | pub fn new_blocking_loopback<T: Instance>(_inner: Peri<'a, T>, config: C...
function blocking_read (line 101) | pub fn blocking_read(&mut self, data: &mut [u8]) -> Result<(), Error> {
function blocking_write (line 125) | pub fn blocking_write(&mut self, data: &[u8]) -> Result<(), Error> {
function blocking_transfer (line 154) | pub fn blocking_transfer(&mut self, read: &mut [u8], write: &[u8]) -> Re...
function blocking_transfer_in_place (line 194) | pub fn blocking_transfer_in_place(&mut self, data: &mut [u8]) -> Result<...
function flush (line 219) | pub fn flush(&mut self) -> Result<(), Error> {
function new_async (line 228) | pub fn new_async<T: Instance>(
function new_async_txonly (line 247) | pub fn new_async_txonly<T: Instance>(
function new_async_rxonly (line 264) | pub fn new_async_rxonly<T: Instance>(
function new_async_loopback (line 284) | pub fn new_async_loopback<T: Instance>(
function async_read (line 296) | pub async fn async_read(&mut self, data: &mut [u8]) -> Result<(), Error> {
function async_write (line 337) | pub async fn async_write(&mut self, data: &[u8]) -> Result<(), Error> {
function async_transfer (line 383) | pub async fn async_transfer(&mut self, read: &mut [u8], write: &[u8]) ->...
function async_transfer_in_place (line 457) | pub async fn async_transfer_in_place(&mut self, data: &mut [u8]) -> Resu...
function async_flush (line 516) | pub fn async_flush(&mut self) -> impl Future<Output = ()> + use<'_, 'a> {
function wait_for (line 533) | fn wait_for<F, U, G>(&mut self, mut f: F, mut g: G) -> impl Future<Outpu...
function new_inner (line 554) | fn new_inner<T: Instance>(
function set_config (line 631) | fn set_config(&mut self, config: &Config) {
function clock (line 635) | fn clock(config: &Config) -> Clock {
function clock_frequency (line 645) | fn clock_frequency(clock: Clock) -> u32 {
function apply_config (line 653) | fn apply_config(regs: &'static crate::pac::spi0::RegisterBlock, config: ...
type Config (line 693) | pub struct Config {
method default (line 701) | fn default() -> Self {
type Info (line 709) | struct Info {
type SealedInstance (line 723) | trait SealedInstance {
method info (line 724) | fn info() -> Info;
type InterruptHandler (line 728) | pub struct InterruptHandler<T: Instance> {
function on_interrupt (line 733) | unsafe fn on_interrupt() {
type Instance (line 763) | pub trait Instance: crate::flexcomm::IntoSpi + SealedInstance + Peripher...
type Sealed (line 796) | pub trait Sealed {}
type SckPin (line 802) | pub trait SckPin<T: Instance>: Pin + sealed::Sealed + PeripheralType {
method as_sck (line 804) | fn as_sck(&self);
type MosiPin (line 808) | pub trait MosiPin<T: Instance>: Pin + sealed::Sealed + PeripheralType {
method as_mosi (line 810) | fn as_mosi(&self);
type MisoPin (line 814) | pub trait MisoPin<T: Instance>: Pin + sealed::Sealed + PeripheralType {
method as_miso (line 816) | fn as_miso(&self);
type TxDma (line 888) | pub trait TxDma<T: Instance>: crate::dma::Channel {}
type RxDma (line 892) | pub trait RxDma<T: Instance>: crate::dma::Channel {}
type Error (line 932) | type Error = Error;
method kind (line 948) | fn kind(&self) -> embedded_hal_1::spi::ErrorKind {
function transfer (line 933) | fn transfer<'w>(&mut self, words: &'w mut [u8]) -> Result<&'w [u8], Self...
type Error (line 940) | type Error = Error;
method kind (line 948) | fn kind(&self) -> embedded_hal_1::spi::ErrorKind {
function write (line 942) | fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
type Error (line 954) | type Error = Error;
method kind (line 948) | fn kind(&self) -> embedded_hal_1::spi::ErrorKind {
function flush (line 958) | fn flush(&mut self) -> Result<(), Self::Error> {
function read (line 962) | fn read(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
function write (line 966) | fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
function transfer (line 970) | fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), Self...
function transfer_in_place (line 974) | fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), Self::Er...
function flush (line 980) | async fn flush(&mut self) -> Result<(), Self::Error> {
function write (line 986) | async fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
function read (line 990) | async fn read(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
function transfer (line 994) | async fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<()...
function transfer_in_place (line 998) | async fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), Se...
type Config (line 1004) | type Config = Config;
type ConfigError (line 1005) | type ConfigError = ();
method set_config (line 1006) | fn set_config(&mut self, config: &Self::Config) -> Result<(), ()> {
FILE: embassy-imxrt/src/flexcomm/uart.rs
type Mode (line 26) | pub trait Mode: Sealed {}
type Blocking (line 29) | pub struct Blocking;
type Async (line 34) | pub struct Async;
type Uart (line 39) | pub struct Uart<'a, M: Mode> {
type UartTx (line 45) | pub struct UartTx<'a, M: Mode> {
type UartRx (line 52) | pub struct UartRx<'a, M: Mode> {
type Config (line 60) | pub struct Config {
method default (line 85) | fn default() -> Self {
type Error (line 104) | pub enum Error {
method kind (line 942) | fn kind(&self) -> embedded_hal_nb::serial::ErrorKind {
type Result (line 139) | pub type Result<T> = core::result::Result<T, Error>;
function new_inner (line 142) | fn new_inner<T: Instance>(tx_dma: Option<Peri<'a, AnyChannel>>) -> Self {
method drop (line 154) | fn drop(&mut self) {
function new_blocking (line 182) | pub fn new_blocking<T: Instance>(_inner: Peri<'a, T>, tx: Peri<'a, impl ...
function write_byte_internal (line 191) | fn write_byte_internal(&mut self, byte: u8) -> Result<()> {
function blocking_write_byte (line 201) | fn blocking_write_byte(&mut self, byte: u8) -> Result<()> {
function write_byte (line 211) | fn write_byte(&mut self, byte: u8) -> Result<()> {
function blocking_write (line 220) | pub fn blocking_write(&mut self, buf: &[u8]) -> Result<()> {
function write (line 230) | pub fn write(&mut self, buf: &[u8]) -> Result<()> {
function blocking_flush (line 239) | pub fn blocking_flush(&mut self) -> Result<()> {
function flush (line 245) | pub fn flush(&mut self) -> Result<()> {
function new_inner (line 255) | fn new_inner<T: Instance>(rx_dma: Option<Peri<'a, AnyChannel>>) -> Self {
method drop (line 267) | fn drop(&mut self) {
function new_blocking (line 294) | pub fn new_blocking<T: Instance>(_inner: Peri<'a, T>, rx: Peri<'a, impl ...
function read_byte_internal (line 305) | fn read_byte_internal(&mut self) -> Result<u8> {
function read_byte (line 325) | fn read_byte(&mut self) -> Result<u8> {
function blocking_read_byte (line 333) | fn blocking_read_byte(&mut self) -> Result<u8> {
function read (line 345) | pub fn read(&mut self, buf: &mut [u8]) -> Result<()> {
function blocking_read (line 354) | pub fn blocking_read(&mut self, buf: &mut [u8]) -> Result<()> {
function init (line 364) | fn init<T: Instance>(
function get_fc_freq (line 400) | fn get_fc_freq(clock: Clock) -> Result<u32> {
function set_baudrate_inner (line 409) | fn set_baudrate_inner<T: Instance>(baudrate: u32, clock: Clock) -> Resul...
function set_uart_config (line 480) | fn set_uart_config<T: Instance>(config: Config) {
function split (line 505) | pub fn split(self) -> (UartTx<'a, M>, UartRx<'a, M>) {
function split_ref (line 512) | pub fn split_ref(&mut self) -> (&mut UartTx<'a, M>, &mut UartRx<'a, M>) {
function new_blocking (line 519) | pub fn new_blocking<T: Instance>(
function blocking_read (line 540) | pub fn blocking_read(&mut self, buf: &mut [u8]) -> Result<()> {
function read (line 546) | pub fn read(&mut self, buf: &mut [u8]) -> Result<()> {
function blocking_write (line 551) | pub fn blocking_write(&mut self, buf: &[u8]) -> Result<()> {
function write (line 557) | pub fn write(&mut self, buf: &[u8]) -> Result<()> {
function blocking_flush (line 562) | pub fn blocking_flush(&mut self) -> Result<()> {
function flush (line 567) | pub fn flush(&mut self) -> Result<()> {
function new_async (line 574) | pub fn new_async<T: Instance>(
function write (line 593) | pub async fn write(&mut self, buf: &[u8]) -> Result<()> {
function flush (line 661) | pub async fn flush(&mut self) -> Result<()> {
function wait_on (line 679) | async fn wait_on<F, U, G>(&mut self, mut f: F, mut g: G) -> U
function new_async (line 702) | pub fn new_async<T: Instance>(
function read (line 721) | pub async fn read(&mut self, buf: &mut [u8]) -> Result<()> {
function new_async (line 791) | pub fn new_async<T: Instance>(
function new_with_rtscts (line 818) | pub fn new_with_rtscts<T: Instance>(
function read (line 848) | pub async fn read(&mut self, buf: &mut [u8]) -> Result<()> {
function write (line 853) | pub async fn write(&mut self, buf: &[u8]) -> Result<()> {
function flush (line 858) | pub async fn flush(&mut self) -> Result<()> {
type Error (line 864) | type Error = Error;
method kind (line 942) | fn kind(&self) -> embedded_hal_nb::serial::ErrorKind {
function read (line 866) | fn read(&mut self) -> core::result::Result<u8, nb::Error<Self::Error>> {
type Error (line 878) | type Error = Error;
method kind (line 942) | fn kind(&self) -> embedded_hal_nb::serial::ErrorKind {
function write (line 880) | fn write(&mut self, word: u8) -> core::result::Result<(), nb::Error<Self...
function flush (line 888) | fn flush(&mut self) -> core::result::Result<(), nb::Error<Self::Error>> {
type Error (line 898) | type Error = Error;
method kind (line 942) | fn kind(&self) -> embedded_hal_nb::serial::ErrorKind {
function bwrite_all (line 900) | fn bwrite_all(&mut self, buffer: &[u8]) -> core::result::Result<(), Self...
function bflush (line 904) | fn bflush(&mut self) -> core::result::Result<(), Self::Error> {
type Error (line 910) | type Error = Error;
method kind (line 942) | fn kind(&self) -> embedded_hal_nb::serial::ErrorKind {
function read (line 912) | fn read(&mut self) -> core::result::Result<u8, nb::Error<Self::Error>> {
type Error (line 918) | type Error = Error;
method kind (line 942) | fn kind(&self) -> embedded_hal_nb::serial::ErrorKind {
function write (line 920) | fn write(&mut self, word: u8) -> core::result::Result<(), nb::Error<Self...
function flush (line 924) | fn flush(&mut self) -> core::result::Result<(), nb::Error<Self::Error>> {
type Error (line 930) | type Error = Error;
method kind (line 942) | fn kind(&self) -> embedded_hal_nb::serial::ErrorKind {
function bwrite_all (line 932) | fn bwrite_all(&mut self, buffer: &[u8]) -> core::result::Result<(), Self...
function bflush (line 936) | fn bflush(&mut self) -> core::result::Result<(), Self::Error> {
type Error (line 954) | type Error = Error;
method kind (line 942) | fn kind(&self) -> embedded_hal_nb::serial::ErrorKind {
type Error (line 958) | type Error = Error;
method kind (line 942) | fn kind(&self) -> embedded_hal_nb::serial::ErrorKind {
type Error (line 962) | type Error = Error;
method kind (line 942) | fn kind(&self) -> embedded_hal_nb::serial::ErrorKind {
function read (line 966) | fn read(&mut self) -> nb::Result<u8, Self::Error> {
function write (line 978) | fn write(&mut self, word: u8) -> nb::Result<(), Self::Error> {
function flush (line 986) | fn flush(&mut self) -> nb::Result<(), Self::Error> {
function read (line 996) | fn read(&mut self) -> core::result::Result<u8, nb::Error<Self::Error>> {
function write (line 1002) | fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
function flush (line 1006) | fn flush(&mut self) -> nb::Result<(), Self::Error> {
type Info (line 1011) | struct Info {
type SealedInstance (line 1017) | trait SealedInstance {
method info (line 1018) | fn info() -> Info;
method index (line 1019) | fn index() -> usize;
type InterruptHandler (line 1023) | pub struct InterruptHandler<T: Instance> {
constant UART_COUNT (line 1027) | const UART_COUNT: usize = 8;
function on_interrupt (line 1031) | unsafe fn on_interrupt() {
type Instance (line 1062) | pub trait Instance: crate::flexcomm::IntoUsart + SealedInstance + Periph...
type TxPin (line 1099) | pub trait TxPin<T: Instance>: Pin + Sealed + PeripheralType {
method as_tx (line 1101) | fn as_tx(&self);
type RxPin (line 1105) | pub trait RxPin<T: Instance>: Pin + Sealed + PeripheralType {
method as_rx (line 1107) | fn as_rx(&self);
type CtsPin (line 1111) | pub trait CtsPin<T: Instance>: Pin + Sealed + PeripheralType {
method as_cts (line 1113) | fn as_cts(&self);
type RtsPin (line 1117) | pub trait RtsPin<T: Instance>: Pin + Sealed + PeripheralType {
method as_rts (line 1119) | fn as_rts(&self);
type TxDma (line 1194) | pub trait TxDma<T: Instance>: crate::dma::Channel {}
type RxDma (line 1198) | pub trait RxDma<T: Instance>: crate::dma::Channel {}
FILE: embassy-imxrt/src/fmt.rs
type NoneError (line 204) | pub struct NoneError;
type Try (line 206) | pub trait Try {
method into_result (line 209) | fn into_result(self) -> Result<Self::Ok, Self::Error>;
type Ok (line 213) | type Ok = T;
type Error (line 214) | type Error = NoneError;
method into_result (line 217) | fn into_result(self) -> Result<T, NoneError> {
type Ok (line 223) | type Ok = T;
type Error (line 224) | type Error = E;
method into_result (line 227) | fn into_result(self) -> Self {
type Bytes (line 232) | pub(crate) struct Bytes<'a>(pub &'a [u8]);
method fmt (line 235) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 241) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
method fmt (line 247) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
function format (line 254) | fn format(&self, fmt: defmt::Formatter) {
FILE: embassy-imxrt/src/gpio.rs
constant PORT_COUNT (line 19) | const PORT_COUNT: usize = 8;
type Level (line 24) | pub enum Level {
method from (line 32) | fn from(val: bool) -> Self {
function from (line 41) | fn from(level: Level) -> bool {
type InterruptType (line 52) | pub enum InterruptType {
function GPIO_INTA (line 62) | fn GPIO_INTA() {
function irq_handler (line 67) | fn irq_handler(port_wakers: &[Option<&PortWaker>]) {
function init (line 94) | pub(crate) fn init() {
type Sense (line 117) | pub trait Sense: Sealed {}
type SenseEnabled (line 123) | pub enum SenseEnabled {}
type SenseDisabled (line 133) | pub enum SenseDisabled {}
type Flex (line 142) | pub struct Flex<'d, S: Sense> {
function set_as_output (line 152) | pub fn set_as_output(&mut self, mode: DriveMode, strength: DriveStrength...
function set_high (line 167) | pub fn set_high(&mut self) {
function set_low (line 176) | pub fn set_low(&mut self) {
function set_level (line 185) | pub fn set_level(&mut self, level: Level) {
function is_set_high (line 194) | pub fn is_set_high(&self) -> bool {
function is_set_low (line 200) | pub fn is_set_low(&self) -> bool {
function toggle (line 205) | pub fn toggle(&mut self) {
method drop (line 216) | fn drop(&mut self) {
function new_with_sense (line 225) | pub fn new_with_sense(pin: Peri<'d, impl GpioPin>) -> Self {
function set_as_input (line 237) | pub fn set_as_input(&mut self, pull: Pull, inverter: Inverter) {
function set_as_special_function (line 251) | pub unsafe fn set_as_special_function(&mut self, func: Function) {
function is_high (line 257) | pub fn is_high(&self) -> bool {
function is_low (line 263) | pub fn is_low(&self) -> bool {
function get_level (line 269) | pub fn get_level(&self) -> Level {
function wait_for_high (line 275) | pub async fn wait_for_high(&mut self) {
function wait_for_low (line 281) | pub async fn wait_for_low(&mut self) {
function wait_for_rising_edge (line 287) | pub async fn wait_for_rising_edge(&mut self) {
function wait_for_falling_edge (line 293) | pub async fn wait_for_falling_edge(&mut self) {
function wait_for_any_edge (line 299) | pub async fn wait_for_any_edge(&mut self) {
function disable_sensing (line 311) | pub fn disable_sensing(self) -> Flex<'d, SenseDisabled> {
function new (line 321) | pub fn new(pin: Peri<'d, impl GpioPin>) -> Self {
function enable_sensing (line 334) | pub fn enable_sensing(self) -> Flex<'d, SenseEnabled> {
type Input (line 343) | pub struct Input<'d> {
function new (line 350) | pub fn new(pin: Peri<'d, impl GpioPin>, pull: Pull, inverter: Inverter) ...
function is_high (line 358) | pub fn is_high(&self) -> bool {
function is_low (line 364) | pub fn is_low(&self) -> bool {
function get_level (line 370) | pub fn get_level(&self) -> Level {
function wait_for_high (line 376) | pub async fn wait_for_high(&mut self) {
function wait_for_low (line 382) | pub async fn wait_for_low(&mut self) {
function wait_for_rising_edge (line 388) | pub async fn wait_for_rising_edge(&mut self) {
function wait_for_falling_edge (line 394) | pub async fn wait_for_falling_edge(&mut self) {
function wait_for_any_edge (line 400) | pub async fn wait_for_any_edge(&mut self) {
type InputFuture (line 406) | struct InputFuture<'d> {
function new (line 411) | fn new(pin: Peri<'d, impl GpioPin>, int_type: InterruptType, level: Leve...
type Output (line 440) | type Output = ();
method poll (line 442) | fn poll(self: FuturePin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::...
type Output (line 476) | pub struct Output<'d> {
function new (line 483) | pub fn new(
function set_high (line 498) | pub fn set_high(&mut self) {
function set_low (line 503) | pub fn set_low(&mut self) {
function toggle (line 508) | pub fn toggle(&mut self) {
function set_level (line 513) | pub fn set_level(&mut self, level: Level) {
function is_set_high (line 519) | pub fn is_set_high(&self) -> bool {
function is_set_low (line 525) | pub fn is_set_low(&self) -> bool {
type SealedPin (line 530) | trait SealedPin: IopctlPin {
method pin_port (line 531) | fn pin_port(&self) -> usize;
method port (line 533) | fn port(&self) -> usize {
method pin (line 537) | fn pin(&self) -> usize {
method block (line 541) | fn block(&self) -> crate::pac::Gpio {
method pin_port (line 562) | fn pin_port(&self) -> usize {
type GpioPin (line 551) | pub trait GpioPin: SealedPin + Sized + PeripheralType + Into<AnyPin> + '...
method degrade (line 553) | fn degrade(self) -> AnyPin {
type PortWaker (line 585) | struct PortWaker {
method get_waker (line 591) | fn get_waker(&self, pin: usize) -> Option<&AtomicWaker> {
type Error (line 786) | type Error = Infallible;
function is_high (line 789) | fn is_high(&self) -> Result<bool, Self::Error> {
function is_low (line 794) | fn is_low(&self) -> Result<bool, Self::Error> {
type Error (line 800) | type Error = Infallible;
function set_high (line 803) | fn set_high(&mut self) -> Result<(), Self::Error> {
function set_low (line 809) | fn set_low(&mut self) -> Result<(), Self::Error> {
function is_set_high (line 817) | fn is_set_high(&self) -> Result<bool, Self::Error> {
function is_set_low (line 822) | fn is_set_low(&self) -> Result<bool, Self::Error> {
type Error (line 828) | type Error = Infallible;
function toggle (line 831) | fn toggle(&mut self) -> Result<(), Self::Error> {
type Error (line 838) | type Error = Infallible;
function is_high (line 841) | fn is_high(&self) -> Result<bool, Self::Error> {
function is_low (line 846) | fn is_low(&self) -> Result<bool, Self::Error> {
type Error (line 852) | type Error = Infallible;
function set_high (line 855) | fn set_high(&mut self) -> Result<(), Self::Error> {
function set_low (line 861) | fn set_low(&mut self) -> Result<(), Self::Error> {
function is_set_high (line 869) | fn is_set_high(&self) -> Result<bool, Self::Error> {
function is_set_low (line 874) | fn is_set_low(&self) -> Result<bool, Self::Error> {
type Error (line 880) | type Error = Infallible;
function toggle (line 883) | fn toggle(&mut self) -> Result<(), Self::Error> {
type Error (line 890) | type Error = Infallible;
function is_high (line 895) | fn is_high(&mut self) -> Result<bool, Self::Error> {
function is_low (line 903) | fn is_low(&mut self) -> Result<bool, Self::Error> {
function set_high (line 910) | fn set_high(&mut self) -> Result<(), Self::Error> {
function set_low (line 916) | fn set_low(&mut self) -> Result<(), Self::Error> {
function is_set_high (line 924) | fn is_set_high(&mut self) -> Result<bool, Self::Error> {
function is_set_low (line 929) | fn is_set_low(&mut self) -> Result<bool, Self::Error> {
function wait_for_high (line 936) | async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
function wait_for_low (line 942) | async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
function wait_for_rising_edge (line 948) | async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
function wait_for_falling_edge (line 954) | async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
function wait_for_any_edge (line 960) | async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
type Error (line 967) | type Error = Infallible;
function is_high (line 972) | fn is_high(&mut self) -> Result<bool, Self::Error> {
function is_low (line 977) | fn is_low(&mut self) -> Result<bool, Self::Error> {
function wait_for_high (line 984) | async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
function wait_for_low (line 990) | async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
function wait_for_rising_edge (line 996) | async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
function wait_for_falling_edge (line 1002) | async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
function wait_for_any_edge (line 1008) | async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
type Error (line 1015) | type Error = Infallible;
function set_high (line 1020) | fn set_high(&mut self) -> Result<(), Self::Error> {
function set_low (line 1026) | fn set_low(&mut self) -> Result<(), Self::Error> {
function is_set_high (line 1034) | fn is_set_high(&mut self) -> Result<bool, Self::Error> {
function is_set_low (line 1039) | fn is_set_low(&mut self) -> Result<bool, Self::Error> {
FILE: embassy-imxrt/src/iopctl.rs
type PioM_N (line 15) | type PioM_N = iopctl::Pio0_0;
type Function (line 20) | pub enum Function {
type Pull (line 44) | pub enum Pull {
type SlewRate (line 56) | pub enum SlewRate {
type DriveStrength (line 66) | pub enum DriveStrength {
type DriveMode (line 76) | pub enum DriveMode {
type Inverter (line 86) | pub enum Inverter {
type SealedPin (line 94) | trait SealedPin {}
type ToAnyPin (line 95) | trait ToAnyPin: SealedPin {
method to_raw (line 97) | fn to_raw(port: u8, pin: u8) -> AnyPin {
type ToFC15Pin (line 104) | trait ToFC15Pin: SealedPin {
method to_raw (line 106) | fn to_raw(pin: u8) -> FC15Pin {
type IopctlPin (line 115) | pub trait IopctlPin: SealedPin {
method set_function (line 123) | fn set_function(&self, function: Function) -> &Self;
method set_pull (line 128) | fn set_pull(&self, pull: Pull) -> &Self;
method enable_input_buffer (line 138) | fn enable_input_buffer(&self) -> &Self;
method disable_input_buffer (line 141) | fn disable_input_buffer(&self) -> &Self;
method set_slew_rate (line 147) | fn set_slew_rate(&self, slew_rate: SlewRate) -> &Self;
method set_drive_strength (line 153) | fn set_drive_strength(&self, strength: DriveStrength) -> &Self;
method enable_analog_multiplex (line 164) | fn enable_analog_multiplex(&self) -> &Self;
method disable_analog_multiplex (line 167) | fn disable_analog_multiplex(&self) -> &Self;
method set_drive_mode (line 175) | fn set_drive_mode(&self, mode: DriveMode) -> &Self;
method set_input_inverter (line 181) | fn set_input_inverter(&self, inverter: Inverter) -> &Self;
method reset (line 184) | fn reset(&self) -> &Self;
type AnyPin (line 188) | pub struct AnyPin {
method steal (line 212) | pub unsafe fn steal(port: u8, pin: u8) -> Self {
method pin_port (line 229) | pub fn pin_port(&self) -> usize {
type FC15Pin (line 235) | pub struct FC15Pin {
method steal (line 258) | pub unsafe fn steal(pin: u8) -> Self {
FILE: embassy-imxrt/src/lib.rs
type Config (line 100) | pub struct Config {
method new (line 121) | pub fn new(clocks: ClockConfig) -> Self {
method default (line 110) | fn default() -> Self {
function init (line 136) | pub fn init(config: config::Config) -> Peripherals {
type Sealed (line 157) | pub trait Sealed {}
type BitIter (line 161) | struct BitIter(u32);
type Item (line 165) | type Item = u32;
method next (line 167) | fn next(&mut self) -> Option<Self::Item> {
FILE: embassy-imxrt/src/rng.rs
type Error (line 19) | pub enum Error {
type InterruptHandler (line 31) | pub struct InterruptHandler<T: Instance> {
function on_interrupt (line 36) | unsafe fn on_interrupt() {
type Rng (line 58) | pub struct Rng<'d> {
function new (line 65) | pub fn new<T: Instance>(
function reset (line 84) | pub fn reset(&mut self) {
function async_fill_bytes (line 89) | pub async fn async_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), ...
function async_fill_chunk (line 100) | async fn async_fill_chunk(&mut self, chunk: &mut [u8]) -> Result<(), Err...
function mask_interrupts (line 156) | fn mask_interrupts(&mut self) {
function unmask_interrupts (line 167) | fn unmask_interrupts(&mut self) {
function enable_interrupts (line 178) | fn enable_interrupts(&mut self) {
function init (line 189) | fn init(&mut self) {
function blocking_next_u32 (line 205) | pub fn blocking_next_u32(&mut self) -> u32 {
function blocking_next_u64 (line 212) | pub fn blocking_next_u64(&mut self) -> u64 {
function blocking_fill_bytes (line 219) | pub fn blocking_fill_bytes(&mut self, dest: &mut [u8]) {
function next_u32 (line 225) | fn next_u32(&mut self) -> u32 {
function next_u64 (line 229) | fn next_u64(&mut self) -> u64 {
function fill_bytes (line 233) | fn fill_bytes(&mut self, dest: &mut [u8]) {
function try_fill_bytes (line 237) | fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand_core_06...
function next_u32 (line 246) | fn next_u32(&mut self) -> u32 {
function next_u64 (line 250) | fn next_u64(&mut self) -> u64 {
function fill_bytes (line 254) | fn fill_bytes(&mut self, dest: &mut [u8]) {
type Info (line 261) | struct Info {
type SealedInstance (line 265) | trait SealedInstance {
method info (line 266) | fn info() -> Info;
method info (line 281) | fn info() -> Info {
type Instance (line 271) | pub trait Instance: SealedInstance + PeripheralType + SysconPeripheral +...
type Interrupt (line 277) | type Interrupt = crate::interrupt::typelevel::RNG;
FILE: embassy-imxrt/src/time_driver.rs
type AlarmState (line 17) | struct AlarmState {
method new (line 24) | const fn new() -> Self {
function rtc (line 32) | fn rtc() -> &'static pac::rtc::RegisterBlock {
function calc_now (line 47) | fn calc_now(period: u32, counter: u32) -> u64 {
type Rtc (line 59) | struct Rtc {
method counter_reg (line 71) | fn counter_reg(&self) -> &pac::rtc::Gpreg {
method compare_reg (line 77) | fn compare_reg(&self) -> &pac::rtc::Gpreg {
method int_en_reg (line 83) | fn int_en_reg(&self) -> &pac::rtc::Gpreg {
method init (line 87) | fn init(&'static self, irq_prio: crate::interrupt::Priority) {
method on_interrupt (line 106) | fn on_interrupt(&self) {
method next_period (line 149) | fn next_period(&self) {
method set_alarm (line 174) | fn set_alarm(&self, cs: CriticalSection, timestamp: u64) -> bool {
method trigger_alarm (line 222) | fn trigger_alarm(&self, cs: CriticalSection) {
method now (line 232) | fn now(&self) -> u64 {
method schedule_wake (line 240) | fn schedule_wake(&self, at: u64, waker: &core::task::Waker) {
function RTC (line 257) | fn RTC() {
function os (line 262) | fn os() -> &'static pac::ostimer0::RegisterBlock {
function gray_to_dec (line 272) | fn gray_to_dec(gray: u64) -> u64 {
function dec_to_gray (line 290) | fn dec_to_gray(dec: u64) -> u64 {
type OsTimer (line 302) | struct OsTimer {
method init (line 310) | fn init(&'static self, irq_prio: crate::interrupt::Priority) {
method set_alarm (line 335) | fn set_alarm(&self, cs: CriticalSection, timestamp: u64) -> bool {
method trigger_alarm (line 362) | fn trigger_alarm(&self, cs: CriticalSection) {
method on_interrupt (line 370) | fn on_interrupt(&self) {
method now (line 383) | fn now(&self) -> u64 {
method schedule_wake (line 390) | fn schedule_wake(&self, at: u64, waker: &core::task::Waker) {
function OS_EVENT (line 407) | fn OS_EVENT() {
function init (line 411) | pub(crate) fn init(irq_prio: crate::interrupt::Priority) {
FILE: embassy-mcxa/src/adc.rs
type TriggerPriorityPolicy (line 24) | pub enum TriggerPriorityPolicy {
type ReferenceVoltage (line 40) | pub enum ReferenceVoltage {
type Config (line 49) | pub struct Config {
method default (line 100) | fn default() -> Self {
type CommandId (line 121) | pub enum CommandId {
method from (line 132) | fn from(value: u8) -> Self {
type Compare (line 148) | pub enum Compare {
method cmp_en (line 169) | fn cmp_en(&self) -> Cmpen {
method get_vals (line 178) | fn get_vals(&self) -> (u16, u16) {
type CompareFunction (line 190) | pub enum CompareFunction {
method get_vals (line 203) | fn get_vals(&self) -> (u16, u16) {
type Channels (line 219) | enum Channels<'a, T> {
type Target (line 225) | type Target = [Peri<'a, AnyAdcPin<T>>];
method deref (line 227) | fn deref(&self) -> &Self::Target {
type Command (line 236) | pub struct Command<'a, T> {
function new_single (line 249) | pub fn new_single(channel: Peri<'a, impl Into<AnyAdcPin<T>> + Peripheral...
function new_looping (line 260) | pub fn new_looping(
function new_multichannel (line 278) | pub fn new_multichannel(channels: &'a [Peri<'a, AnyAdcPin<T>>], config: ...
type CommandConfig (line 302) | pub struct CommandConfig {
method default (line 321) | fn default() -> Self {
type Trigger (line 337) | pub struct Trigger {
method default (line 349) | fn default() -> Self {
type Error (line 364) | pub enum Error {
type Conversion (line 386) | pub struct Conversion {
type Adc (line 398) | pub struct Adc<'a, M: Mode> {
function new_blocking (line 408) | pub fn new_blocking<T: Instance>(
function new_async (line 434) | pub fn new_async<T: Instance>(
function wait_get_conversion (line 466) | pub async fn wait_get_conversion(&mut self) -> Option<Conversion> {
function wait_conversion (line 490) | pub async fn wait_conversion(&mut self) -> Conversion {
function do_software_trigger (line 524) | pub fn do_software_trigger(&mut self, trigger_id_mask: u8) -> Result<(),...
function do_reset_fifo (line 535) | pub fn do_reset_fifo(&mut self) {
function try_get_conversion (line 548) | pub fn try_get_conversion(&mut self) -> Result<Conversion, Error> {
function new_inner (line 566) | fn new_inner(
function do_offset_calibration (line 728) | pub fn do_offset_calibration(&mut self) {
function get_gain_conv_result (line 746) | fn get_gain_conv_result(&mut self, mut gain_adjustment: f32) -> u32 {
function do_auto_calibration (line 765) | pub fn do_auto_calibration(&mut self) {
method drop (line 791) | fn drop(&mut self) {
type InterruptHandler (line 805) | pub struct InterruptHandler<T: Instance> {
function on_interrupt (line 810) | unsafe fn on_interrupt() {
type Sealed (line 826) | pub trait Sealed {}
type SealedAdcPin (line 829) | pub trait SealedAdcPin<T: super::Instance> {}
type Info (line 832) | struct Info {
method regs (line 841) | fn regs(&self) -> pac::adc::Adc {
method wait_cell (line 846) | fn wait_cell(&self) -> &WaitCell {
type SealedInstance (line 851) | trait SealedInstance: Gate<MrccPeriphConfig = AdcConfig> {
method info (line 852) | fn info() -> &'static Info;
constant PERF_INT_INCR (line 854) | const PERF_INT_INCR: fn();
type Instance (line 859) | pub trait Instance: SealedInstance + PeripheralType {
type AdcPin (line 892) | pub trait AdcPin<T: Instance>: sealed::SealedAdcPin<T> + GpioPin + Perip...
method channel (line 894) | fn channel(&self) -> u8;
method degrade (line 897) | fn degrade(self) -> AnyAdcPin<T> {
type AnyAdcPin (line 908) | pub struct AnyAdcPin<T> {
function mux (line 916) | fn mux(&self) {
function demux (line 928) | fn demux(&self) {
function temperature (line 935) | pub fn temperature() -> Peri<'static, Self> {
function from (line 948) | fn from(value: P) -> Self {
type Mode (line 957) | pub trait Mode: sealed::Sealed {}
type Blocking (line 960) | pub struct Blocking;
type Async (line 965) | pub struct Async;
FILE: embassy-mcxa/src/cdog.rs
type Result (line 20) | pub type Result<T> = core::result::Result<T, Error>;
type Error (line 25) | pub enum Error {
type FaultControl (line 35) | pub enum FaultControl {
method from (line 46) | fn from(val: FaultControl) -> Self {
type PauseControl (line 60) | pub enum PauseControl {
type LockControl (line 73) | pub enum LockCont
Copy disabled (too large)
Download .json
Condensed preview — 2345 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (13,755K chars).
[
{
"path": ".gitattributes",
"chars": 920,
"preview": "* text=auto\n\n*.adoc text\n*.html text\n*.in text\n*.json text\n*.md text\n*.proto text\n*.py "
},
{
"path": ".github/ci/book.sh",
"chars": 545,
"preview": "#!/bin/bash\n## on push branch=main\n## priority -100\n## dedup dequeue\n## cooldown 15m\n\nset -euxo pipefail\n\nmake -C docs\n\n"
},
{
"path": ".github/ci/build-nightly.sh",
"chars": 917,
"preview": "#!/bin/bash\n## on push branch~=gh-readonly-queue/main/.*\n## on pull_request\n\nset -euo pipefail\n\nexport RUSTUP_HOME=/ci/c"
},
{
"path": ".github/ci/build-xtensa.sh",
"chars": 938,
"preview": "#!/bin/bash\n## on push branch~=gh-readonly-queue/main/.*\n## on pull_request\n\nset -euo pipefail\n\nexport RUSTUP_HOME=/ci/c"
},
{
"path": ".github/ci/build.sh",
"chars": 1119,
"preview": "#!/bin/bash\n## on push branch~=gh-readonly-queue/main/.*\n## on pull_request\n\nset -euo pipefail\n\nexport RUSTUP_HOME=/ci/c"
},
{
"path": ".github/ci/doc.sh",
"chars": 782,
"preview": "#!/bin/bash\n## on push branch=main\n## priority -100\n## dedup dequeue\n## cooldown 15m\n\nset -euxo pipefail\n\nexport RUSTUP_"
},
{
"path": ".github/ci/janitor.sh",
"chars": 441,
"preview": "#!/bin/bash\n## on push branch~=gh-readonly-queue/main/.*\n## on pull_request\n\nset -euo pipefail\n\nexport RUSTUP_HOME=/ci/c"
},
{
"path": ".github/ci/rustfmt.sh",
"chars": 377,
"preview": "#!/bin/bash\n## on push branch~=gh-readonly-queue/main/.*\n## on pull_request\n\nset -euo pipefail\n\nexport RUSTUP_HOME=/ci/c"
},
{
"path": ".github/ci/test-nightly.sh",
"chars": 684,
"preview": "#!/bin/bash\n## on push branch~=gh-readonly-queue/main/.*\n## on pull_request\n\nset -euo pipefail\n\nexport RUSTUP_HOME=/ci/c"
},
{
"path": ".github/ci/test.sh",
"chars": 2163,
"preview": "#!/bin/bash\n## on push branch~=gh-readonly-queue/main/.*\n## on pull_request\n\nset -euo pipefail\n\nexport RUSTUP_HOME=/ci/c"
},
{
"path": ".github/workflows/matrix-bot-issues.yml",
"chars": 2208,
"preview": "name: Matrix bot for issues\non:\n issues:\n types: [opened]\n\njobs:\n notify:\n if: github.repository == 'embassy-rs/"
},
{
"path": ".github/workflows/matrix-bot.yml",
"chars": 2326,
"preview": "name: Matrix bot\non:\n pull_request_target:\n types: [opened, closed]\n\njobs:\n notify:\n if: github.repository == 'e"
},
{
"path": ".gitignore",
"chars": 201,
"preview": "target\ntarget_ci\ntarget_ci_stable\nCargo.lock\nthird_party\nwebroot\n/Cargo.toml\nout/\n# editor artifacts\n.zed\n.neoconf.json\n"
},
{
"path": ".helix/languages.toml",
"chars": 393,
"preview": "[language-server.rust-analyzer.config.cargo]\nallTargets = false\nnoDefaultFeatures = true\ntarget = \"thumbv8m.main-none-ea"
},
{
"path": ".vscode/.gitignore",
"chars": 51,
"preview": "*.cortex-debug.*.json\nlaunch.json\ntasks.json\n*.cfg\n"
},
{
"path": ".vscode/extensions.json",
"chars": 480,
"preview": "{\n\t// See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.\n\t// Extension identif"
},
{
"path": ".vscode/settings.json",
"chars": 2547,
"preview": "{\n \"[toml]\": {\n \"editor.formatOnSave\": false\n },\n \"[markdown]\": {\n \"editor.formatOnSave\": false\n },\n \"rust-an"
},
{
"path": "LICENSE-APACHE",
"chars": 10847,
"preview": " Apache License\n Version 2.0, January 2004\n http"
},
{
"path": "LICENSE-CC-BY-SA",
"chars": 20134,
"preview": "Attribution-ShareAlike 4.0 International\n\n=======================================================================\n\nCreat"
},
{
"path": "LICENSE-MIT",
"chars": 1067,
"preview": "Copyright (c) Embassy project contributors\n\nPermission is hereby granted, free of charge, to any\nperson obtaining a copy"
},
{
"path": "NOTICE.md",
"chars": 587,
"preview": "# Notices for Embassy\n\nThis content is produced and maintained by the Embassy project contributors.\n\n## Copyright\n\nAll c"
},
{
"path": "README.md",
"chars": 8772,
"preview": "# Embassy\n\nEmbassy is the next-generation framework for embedded applications. Write safe, correct, and energy-efficient"
},
{
"path": "RELEASE.md",
"chars": 1871,
"preview": "# RELEASE.md\n\nThis document outlines the process for releasing Embassy crates using `cargo-release` and the `release/bum"
},
{
"path": "ci-nightly.sh",
"chars": 303,
"preview": "#!/bin/bash\n\nset -eo pipefail\n\nexport RUSTFLAGS=-Dwarnings\nexport DEFMT_LOG=trace,embassy_hal_internal=debug,embassy_net"
},
{
"path": "ci-xtensa.sh",
"chars": 330,
"preview": "#!/bin/bash\n\nset -eo pipefail\n\nexport RUSTFLAGS=-Dwarnings\nexport DEFMT_LOG=trace,embassy_hal_internal=debug,embassy_net"
},
{
"path": "ci.sh",
"chars": 2624,
"preview": "#!/bin/bash\n\nset -eo pipefail\n\nif ! command -v cargo-batch &> /dev/null; then\n echo \"cargo-batch could not be found. "
},
{
"path": "cyw43/CHANGELOG.md",
"chars": 1768,
"preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Change"
},
{
"path": "cyw43/Cargo.toml",
"chars": 2549,
"preview": "[package]\nname = \"cyw43\"\nversion = \"0.7.0\"\nedition = \"2024\"\ndescription = \"Rust driver for the CYW43439 WiFi chip, used "
},
{
"path": "cyw43/README.md",
"chars": 2100,
"preview": "# cyw43\n\nRust driver for the CYW43439 wifi+bluetooth chip. Implementation based on [Infineon/wifi-host-driver](https://g"
},
{
"path": "cyw43/src/bluetooth.rs",
"chars": 20526,
"preview": "use core::cell::RefCell;\nuse core::future::Future;\nuse core::mem::MaybeUninit;\n\nuse bt_hci::transport::WithIndicator;\nus"
},
{
"path": "cyw43/src/consts.rs",
"chars": 22888,
"preview": "#![allow(unused)]\n\npub(crate) const FUNC_BUS: u32 = 0;\npub(crate) const FUNC_BACKPLANE: u32 = 1;\npub(crate) const FUNC_W"
},
{
"path": "cyw43/src/control.rs",
"chars": 26944,
"preview": "use core::cmp::{max, min};\nuse core::iter::zip;\nuse core::sync::atomic::AtomicBool;\nuse core::sync::atomic::Ordering::Re"
},
{
"path": "cyw43/src/countries.rs",
"chars": 20419,
"preview": "#![allow(unused)]\n\npub struct Country {\n pub code: [u8; 2],\n pub rev: u16,\n}\n\n/// AF Afghanistan\npub const AFGHANI"
},
{
"path": "cyw43/src/events.rs",
"chars": 12377,
"preview": "#![allow(dead_code)]\n#![allow(non_camel_case_types)]\n\nuse core::cell::RefCell;\n\nuse embassy_sync::blocking_mutex::raw::N"
},
{
"path": "cyw43/src/fmt.rs",
"chars": 6494,
"preview": "#![macro_use]\n#![allow(unused)]\n\nuse core::fmt::{Debug, Display, LowerHex};\n\n#[cfg(all(feature = \"defmt\", feature = \"log"
},
{
"path": "cyw43/src/ioctl.rs",
"chars": 3159,
"preview": "use core::cell::{Cell, RefCell};\nuse core::future::{Future, poll_fn};\nuse core::task::{Poll, Waker};\n\nuse embassy_sync::"
},
{
"path": "cyw43/src/lib.rs",
"chars": 10186,
"preview": "#![no_std]\n#![no_main]\n#![allow(async_fn_in_trait)]\n#![allow(unsafe_op_in_unsafe_fn)]\n#![deny(unused_must_use)]\n#![doc ="
},
{
"path": "cyw43/src/runner.rs",
"chars": 39933,
"preview": "use core::sync::atomic::AtomicBool;\nuse core::sync::atomic::Ordering::Relaxed;\n\nuse aligned::{A4, Aligned};\nuse embassy_"
},
{
"path": "cyw43/src/sdio.rs",
"chars": 16714,
"preview": "use core::slice;\n\nuse aligned::{A4, Aligned};\nuse embassy_time::{Duration, Timer};\n\nuse crate::consts::*;\nuse crate::run"
},
{
"path": "cyw43/src/spi.rs",
"chars": 13892,
"preview": "use aligned::{A4, Aligned};\nuse embassy_futures::yield_now;\nuse embassy_time::Timer;\nuse embedded_hal_1::digital::Output"
},
{
"path": "cyw43/src/structs.rs",
"chars": 14742,
"preview": "use crate::events::Event;\nuse crate::fmt::Bytes;\n\nmacro_rules! impl_bytes {\n ($t:ident) => {\n impl $t {\n "
},
{
"path": "cyw43/src/util.rs",
"chars": 3221,
"preview": "#![allow(unused)]\n\nuse core::slice;\n\nuse aligned::{A4, Aligned};\nuse embassy_time::{Duration, Ticker};\n\n/// Defines a `r"
},
{
"path": "cyw43-firmware/.gitignore",
"chars": 11,
"preview": "*.exe\n*.pdb"
},
{
"path": "cyw43-firmware/LICENSE-permissive-binary-license-1.0.txt",
"chars": 2415,
"preview": "Permissive Binary License\n\nVersion 1.0, July 2019\n\nRedistribution. Redistribution and use in binary form, without\nmodif"
},
{
"path": "cyw43-firmware/README.md",
"chars": 608,
"preview": "# WiFi + Bluetooth firmware blobs\n\nFirmware obtained from https://github.com/georgerobotics/cyw43-driver/tree/main/firmw"
},
{
"path": "cyw43-firmware/write_nvrams.rs",
"chars": 2455,
"preview": "use std::fs::File;\nuse std::io::{self, BufWriter, Write};\n\nfn main() -> io::Result<()> {\n let nvrams = [\n (\n "
},
{
"path": "cyw43-pio/CHANGELOG.md",
"chars": 909,
"preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Change"
},
{
"path": "cyw43-pio/Cargo.toml",
"chars": 1034,
"preview": "[package]\nname = \"cyw43-pio\"\nversion = \"0.10.0\"\nedition = \"2024\"\ndescription = \"RP2040 PIO SPI implementation for cyw43\""
},
{
"path": "cyw43-pio/README.md",
"chars": 173,
"preview": "# cyw43-pio\n\nRP2040 PIO driver for the nonstandard half-duplex SPI used in the Pico W. The PIO driver offloads SPI commu"
},
{
"path": "cyw43-pio/src/lib.rs",
"chars": 11175,
"preview": "#![no_std]\n#![allow(async_fn_in_trait)]\n#![doc = include_str!(\"../README.md\")]\n#![warn(missing_docs)]\n\nuse core::slice;\n"
},
{
"path": "docs/Makefile",
"chars": 105,
"preview": "all:\n\tasciidoctor -d book -D book/ index.adoc\n\tcp -r images book\n\nclean:\n\trm -rf book\n\n.PHONY: all clean\n"
},
{
"path": "docs/README.md",
"chars": 1153,
"preview": "# embassy docs\n\nThe documentation hosted at [https://embassy.dev/book](https://embassy.dev/book). Building the documenta"
},
{
"path": "docs/examples/basic/.cargo/config.toml",
"chars": 246,
"preview": "[target.'cfg(all(target_arch = \"arm\", target_os = \"none\"))']\n# replace nRF82840_xxAA with your chip as listed in `probe-"
},
{
"path": "docs/examples/basic/Cargo.toml",
"chars": 834,
"preview": "[package]\nauthors = [\"Dario Nieuwenhuis <dirbaio@dirbaio.net>\"]\nedition = \"2024\"\nname = \"embassy-basic-example\"\nversion "
},
{
"path": "docs/examples/basic/build.rs",
"chars": 1445,
"preview": "//! This build script copies the `memory.x` file from the crate root into\n//! a directory where the linker can always fi"
},
{
"path": "docs/examples/basic/memory.x",
"chars": 215,
"preview": "MEMORY\n{\n /* NOTE 1 K = 1 KiBi = 1024 bytes */\n /* These values correspond to the NRF52840 with Softdevices S140 7.0.1"
},
{
"path": "docs/examples/basic/src/main.rs",
"chars": 1256,
"preview": "#![no_std]\n#![no_main]\n\nuse defmt::*;\nuse embassy_executor::Spawner;\nuse embassy_nrf::Peri;\nuse embassy_nrf::gpio::{AnyP"
},
{
"path": "docs/examples/layer-by-layer/.cargo/config.toml",
"chars": 338,
"preview": "[target.'cfg(all(target_arch = \"arm\", target_os = \"none\"))']\n# replace your chip as listed in `probe-rs chip list`\nrunne"
},
{
"path": "docs/examples/layer-by-layer/Cargo.toml",
"chars": 241,
"preview": "[workspace]\nresolver = \"2\"\nmembers = [\n \"blinky-pac\",\n \"blinky-hal\",\n \"blinky-async\",\n]\n\n[profile.release]\ncode"
},
{
"path": "docs/examples/layer-by-layer/blinky-async/Cargo.toml",
"chars": 660,
"preview": "[package]\nname = \"blinky-async\"\nversion = \"0.1.0\"\nedition = \"2024\"\nlicense = \"MIT OR Apache-2.0\"\n\npublish = false\n[depen"
},
{
"path": "docs/examples/layer-by-layer/blinky-async/src/main.rs",
"chars": 794,
"preview": "#![no_std]\n#![no_main]\n\nuse embassy_executor::Spawner;\nuse embassy_stm32::exti::{self, ExtiInput};\nuse embassy_stm32::gp"
},
{
"path": "docs/examples/layer-by-layer/blinky-hal/Cargo.toml",
"chars": 515,
"preview": "[package]\nname = \"blinky-hal\"\nversion = \"0.1.0\"\nedition = \"2024\"\nlicense = \"MIT OR Apache-2.0\"\n\npublish = false\n[depende"
},
{
"path": "docs/examples/layer-by-layer/blinky-hal/src/main.rs",
"chars": 477,
"preview": "#![no_std]\n#![no_main]\n\nuse cortex_m_rt::entry;\nuse embassy_stm32::gpio::{Input, Level, Output, Pull, Speed};\nuse {defmt"
},
{
"path": "docs/examples/layer-by-layer/blinky-irq/Cargo.toml",
"chars": 558,
"preview": "[workspace]\n\n[package]\nname = \"blinky-irq\"\nversion = \"0.1.0\"\nedition = \"2024\"\nlicense = \"MIT OR Apache-2.0\"\n\npublish = f"
},
{
"path": "docs/examples/layer-by-layer/blinky-irq/src/main.rs",
"chars": 2511,
"preview": "#![no_std]\n#![no_main]\n\nuse core::cell::RefCell;\n\nuse cortex_m::interrupt::Mutex;\nuse cortex_m::peripheral::NVIC;\nuse co"
},
{
"path": "docs/examples/layer-by-layer/blinky-pac/Cargo.toml",
"chars": 464,
"preview": "[package]\nname = \"blinky-pac\"\nversion = \"0.1.0\"\nedition = \"2024\"\nlicense = \"MIT OR Apache-2.0\"\n\npublish = false\n[depende"
},
{
"path": "docs/examples/layer-by-layer/blinky-pac/src/main.rs",
"chars": 1313,
"preview": "#![no_std]\n#![no_main]\n\nuse pac::gpio::vals;\nuse {defmt_rtt as _, panic_probe as _, stm32_metapac as pac};\n\n#[cortex_m_r"
},
{
"path": "docs/examples/layer-by-layer/memory.x",
"chars": 131,
"preview": "MEMORY\n{\n FLASH : ORIGIN = 0x08000000, LENGTH = 2048K /* BANK_1 */\n RAM : ORIGIN = 0x20000000, LENGTH = 640K /*"
},
{
"path": "docs/images/embassy_executor.drawio",
"chars": 1467,
"preview": "<mxfile host=\"app.diagrams.net\" modified=\"2021-12-10T08:37:46.039Z\" agent=\"5.0 (Macintosh)\" etag=\"F30pje_XkDZMiNl31GPU\" "
},
{
"path": "docs/images/embassy_irq.drawio",
"chars": 1407,
"preview": "<mxfile host=\"app.diagrams.net\" modified=\"2021-12-10T09:18:58.548Z\" agent=\"5.0 (Macintosh)\" etag=\"zuUk3bLZCCXvlBU683Ur\" "
},
{
"path": "docs/index.adoc",
"chars": 507,
"preview": ":description: Embassy Book\n:sectanchors:\n:doctype: book\n:toc:\n:toc-placement: left\n:toclevels: 2\n:imagesdir: images\n:sou"
},
{
"path": "docs/pages/basic_application.adoc",
"chars": 3201,
"preview": "= A basic Embassy application\n\nSo you've got one of the examples running, but what now? Let's go through a simple Embass"
},
{
"path": "docs/pages/beginners.adoc",
"chars": 657,
"preview": "= For beginners\n\nThe articles in this section are primarily aimed at users new to Embassy,\nshowing how to get started, h"
},
{
"path": "docs/pages/best_practices.adoc",
"chars": 1965,
"preview": "= Best Practices\n\nOver time, a couple of best practices have emerged. The following list should serve as a guideline for"
},
{
"path": "docs/pages/bootloader.adoc",
"chars": 7455,
"preview": "= Bootloader\n\n`embassy-boot` is a lightweight bootloader supporting firmware application upgrades in a power-fail-safe w"
},
{
"path": "docs/pages/developer.adoc",
"chars": 225,
"preview": "= For developers\n\nThis section covers the internals of Embassy, aimed at contributors and developers who want to underst"
},
{
"path": "docs/pages/developer_stm32.adoc",
"chars": 4057,
"preview": "= STM32\n\n== Understanding metapac\n\nWhen a project that imports `embassy-stm32` is compiled, that project selects the fea"
},
{
"path": "docs/pages/embassy_in_the_wild.adoc",
"chars": 3607,
"preview": "= Embassy in the wild!\n\nHere are known examples of real-world projects which make use of Embassy. Feel free to link:http"
},
{
"path": "docs/pages/examples.adoc",
"chars": 204,
"preview": "= Examples\n\nEmbassy provides examples for all HALs supported. You can find them in the `examples/` folder.\n\n\nMain loop e"
},
{
"path": "docs/pages/faq.adoc",
"chars": 24421,
"preview": "= Frequently Asked Questions\n\nThese are a list of unsorted, commonly asked questions and answers.\n\nPlease feel free to a"
},
{
"path": "docs/pages/getting_started.adoc",
"chars": 7291,
"preview": "= Getting started\n\nSo you want to try Embassy, great! To get started, there are a few tools you need to install:\n\n* link"
},
{
"path": "docs/pages/hal.adoc",
"chars": 935,
"preview": "= Hardware Abstraction Layer (HAL)\n\nEmbassy provides HALs for several microcontroller families:\n\n* `embassy-nrf` for the"
},
{
"path": "docs/pages/imxrt.adoc",
"chars": 441,
"preview": "= Embassy iMXRT HAL\n\nThe link:https://github.com/embassy-rs/embassy/tree/main/embassy-imxrt[Embassy iMXRT HAL] is based "
},
{
"path": "docs/pages/layer_by_layer.adoc",
"chars": 5674,
"preview": "= From bare metal to async Rust\n\nIf you're new to Embassy, it can be overwhelming to grasp all the terminology and conce"
},
{
"path": "docs/pages/mcxa.adoc",
"chars": 430,
"preview": "= Embassy MCX-A HAL\n\nThe link:https://github.com/embassy-rs/embassy/tree/main/embassy-mcxa[Embassy MCX-A HAL] is based o"
},
{
"path": "docs/pages/microchip.adoc",
"chars": 391,
"preview": "= Embassy Microchip HAL\n\nThe link:https://github.com/embassy-rs/embassy/tree/main/embassy-microchip[Embassy Microchip HA"
},
{
"path": "docs/pages/new_project.adoc",
"chars": 8870,
"preview": "= Starting a new project\n\nOnce you’ve successfully xref:#_getting_started[run some example projects], the next step is t"
},
{
"path": "docs/pages/nrf.adoc",
"chars": 562,
"preview": "= Embassy nRF HAL\n\nThe link:https://github.com/embassy-rs/embassy/tree/main/embassy-nrf[Embassy nRF HAL] is based on the"
},
{
"path": "docs/pages/overview.adoc",
"chars": 7737,
"preview": "= Introduction\n\nEmbassy is a project to make async/await a first-class option for embedded development.\n\n== What is asyn"
},
{
"path": "docs/pages/project_structure.adoc",
"chars": 2666,
"preview": "= Project Structure\n\nThere are many ways to configure embassy and its components for your exact application. The link:ht"
},
{
"path": "docs/pages/runtime.adoc",
"chars": 3642,
"preview": "= Embassy executor\n\nThe Embassy executor is an async/await executor designed for embedded usage along with support funct"
},
{
"path": "docs/pages/sharing_peripherals.adoc",
"chars": 5422,
"preview": "= Sharing peripherals between tasks\n\nOften, more than one task needs to access the same resource (pin, communication int"
},
{
"path": "docs/pages/stm32.adoc",
"chars": 1350,
"preview": "= Embassy STM32 HAL\n\nThe link:https://github.com/embassy-rs/embassy/tree/main/embassy-stm32[Embassy STM32 HAL] is based "
},
{
"path": "docs/pages/system.adoc",
"chars": 445,
"preview": "= System description\n\nThis section describes different parts of Embassy in more detail.\n\ninclude::runtime.adoc[leveloffs"
},
{
"path": "docs/pages/time_keeping.adoc",
"chars": 2293,
"preview": "= Time-keeping\n\nIn an embedded program, delaying a task is one of the most common actions taken. In an event loop, delay"
},
{
"path": "embassy-boot/CHANGELOG.md",
"chars": 611,
"preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Change"
},
{
"path": "embassy-boot/Cargo.toml",
"chars": 2231,
"preview": "[package]\nedition = \"2024\"\nname = \"embassy-boot\"\nversion = \"0.7.0\"\ndescription = \"A lightweight bootloader supporting fi"
},
{
"path": "embassy-boot/README.md",
"chars": 2203,
"preview": "# embassy-boot\n\nAn [Embassy](https://embassy.dev) project.\n\nA lightweight bootloader supporting firmware updates in a po"
},
{
"path": "embassy-boot/src/boot_loader.rs",
"chars": 19582,
"preview": "use core::cell::RefCell;\n\nuse embassy_embedded_hal::flash::partition::BlockingPartition;\nuse embassy_sync::blocking_mute"
},
{
"path": "embassy-boot/src/digest_adapters/ed25519_dalek.rs",
"chars": 676,
"preview": "use digest::typenum::U64;\nuse digest::{FixedOutput, HashMarker, OutputSizeUser, Update};\nuse ed25519_dalek::Digest;\n\npub"
},
{
"path": "embassy-boot/src/digest_adapters/mod.rs",
"chars": 121,
"preview": "#[cfg(feature = \"ed25519-dalek\")]\npub(crate) mod ed25519_dalek;\n\n#[cfg(feature = \"ed25519-salty\")]\npub(crate) mod salty;"
},
{
"path": "embassy-boot/src/digest_adapters/salty.rs",
"chars": 619,
"preview": "use digest::typenum::U64;\nuse digest::{FixedOutput, HashMarker, OutputSizeUser, Update};\n\npub struct Sha512(salty::Sha51"
},
{
"path": "embassy-boot/src/firmware_updater/asynch.rs",
"chars": 18994,
"preview": "use digest::Digest;\n#[cfg(target_os = \"none\")]\nuse embassy_embedded_hal::flash::partition::Partition;\n#[cfg(target_os = "
},
{
"path": "embassy-boot/src/firmware_updater/blocking.rs",
"chars": 20672,
"preview": "use digest::Digest;\n#[cfg(target_os = \"none\")]\nuse embassy_embedded_hal::flash::partition::BlockingPartition;\n#[cfg(targ"
},
{
"path": "embassy-boot/src/firmware_updater/mod.rs",
"chars": 1672,
"preview": "mod asynch;\nmod blocking;\n\npub use asynch::{FirmwareState, FirmwareUpdater};\npub use blocking::{BlockingFirmwareState, B"
},
{
"path": "embassy-boot/src/fmt.rs",
"chars": 6494,
"preview": "#![macro_use]\n#![allow(unused)]\n\nuse core::fmt::{Debug, Display, LowerHex};\n\n#[cfg(all(feature = \"defmt\", feature = \"log"
},
{
"path": "embassy-boot/src/lib.rs",
"chars": 11976,
"preview": "#![no_std]\n#![allow(async_fn_in_trait)]\n#![allow(unsafe_op_in_unsafe_fn)]\n#![warn(missing_docs)]\n#![doc = include_str!(\""
},
{
"path": "embassy-boot/src/mem_flash.rs",
"chars": 4930,
"preview": "#![allow(unused)]\n\nuse core::ops::{Bound, Range, RangeBounds};\n\nuse embedded_storage::nor_flash::{ErrorType, NorFlash, N"
},
{
"path": "embassy-boot/src/test_flash/asynch.rs",
"chars": 1904,
"preview": "use embassy_embedded_hal::flash::partition::Partition;\nuse embassy_sync::blocking_mutex::raw::NoopRawMutex;\nuse embassy_"
},
{
"path": "embassy-boot/src/test_flash/blocking.rs",
"chars": 2136,
"preview": "use core::cell::RefCell;\n\nuse embassy_embedded_hal::flash::partition::BlockingPartition;\nuse embassy_sync::blocking_mute"
},
{
"path": "embassy-boot/src/test_flash/mod.rs",
"chars": 110,
"preview": "mod asynch;\nmod blocking;\n\npub(crate) use asynch::AsyncTestFlash;\npub(crate) use blocking::BlockingTestFlash;\n"
},
{
"path": "embassy-boot-nrf/CHANGELOG.md",
"chars": 608,
"preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Change"
},
{
"path": "embassy-boot-nrf/Cargo.toml",
"chars": 1863,
"preview": "[package]\nedition = \"2024\"\nname = \"embassy-boot-nrf\"\nversion = \"0.11.0\"\ndescription = \"Bootloader lib for nRF chips\"\nlic"
},
{
"path": "embassy-boot-nrf/README.md",
"chars": 1673,
"preview": "# embassy-boot-nrf\n\nAn [Embassy](https://embassy.dev) project.\n\nAn adaptation of `embassy-boot` for nRF.\n\n## Features\n\n-"
},
{
"path": "embassy-boot-nrf/src/fmt.rs",
"chars": 6494,
"preview": "#![macro_use]\n#![allow(unused)]\n\nuse core::fmt::{Debug, Display, LowerHex};\n\n#[cfg(all(feature = \"defmt\", feature = \"log"
},
{
"path": "embassy-boot-nrf/src/lib.rs",
"chars": 5861,
"preview": "#![no_std]\n#![allow(unsafe_op_in_unsafe_fn)]\n#![warn(missing_docs)]\n#![doc = include_str!(\"../README.md\")]\nmod fmt;\n\npub"
},
{
"path": "embassy-boot-rp/CHANGELOG.md",
"chars": 512,
"preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Change"
},
{
"path": "embassy-boot-rp/Cargo.toml",
"chars": 1993,
"preview": "[package]\nedition = \"2024\"\nname = \"embassy-boot-rp\"\nversion = \"0.10.0\"\ndescription = \"Bootloader lib for RP2040 chips\"\nl"
},
{
"path": "embassy-boot-rp/README.md",
"chars": 320,
"preview": "# embassy-boot-rp\n\nAn [Embassy](https://embassy.dev) project.\n\nAn adaptation of `embassy-boot` for RP2040.\n\nNOTE: The ap"
},
{
"path": "embassy-boot-rp/build.rs",
"chars": 217,
"preview": "use std::env;\n\nfn main() {\n let target = env::var(\"TARGET\").unwrap();\n if target.starts_with(\"thumbv6m-\") {\n "
},
{
"path": "embassy-boot-rp/src/fmt.rs",
"chars": 6494,
"preview": "#![macro_use]\n#![allow(unused)]\n\nuse core::fmt::{Debug, Display, LowerHex};\n\n#[cfg(all(feature = \"defmt\", feature = \"log"
},
{
"path": "embassy-boot-rp/src/lib.rs",
"chars": 4223,
"preview": "#![no_std]\n#![allow(unsafe_op_in_unsafe_fn)]\n#![warn(missing_docs)]\n#![doc = include_str!(\"../README.md\")]\nmod fmt;\n\npub"
},
{
"path": "embassy-boot-stm32/CHANGELOG.md",
"chars": 554,
"preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Change"
},
{
"path": "embassy-boot-stm32/Cargo.toml",
"chars": 1957,
"preview": "[package]\nedition = \"2024\"\nname = \"embassy-boot-stm32\"\nversion = \"0.8.0\"\ndescription = \"Bootloader lib for STM32 chips\"\n"
},
{
"path": "embassy-boot-stm32/README.md",
"chars": 224,
"preview": "# embassy-boot-stm32\n\nAn [Embassy](https://embassy.dev) project.\n\nAn adaptation of `embassy-boot` for STM32.\n\n## Feature"
},
{
"path": "embassy-boot-stm32/build.rs",
"chars": 217,
"preview": "use std::env;\n\nfn main() {\n let target = env::var(\"TARGET\").unwrap();\n if target.starts_with(\"thumbv6m-\") {\n "
},
{
"path": "embassy-boot-stm32/src/fmt.rs",
"chars": 6494,
"preview": "#![macro_use]\n#![allow(unused)]\n\nuse core::fmt::{Debug, Display, LowerHex};\n\n#[cfg(all(feature = \"defmt\", feature = \"log"
},
{
"path": "embassy-boot-stm32/src/lib.rs",
"chars": 2127,
"preview": "#![no_std]\n#![allow(unsafe_op_in_unsafe_fn)]\n#![warn(missing_docs)]\n#![doc = include_str!(\"../README.md\")]\nmod fmt;\n\npub"
},
{
"path": "embassy-embedded-hal/CHANGELOG.md",
"chars": 1372,
"preview": "# Changelog for embassy-embedded-hal\n\nAll notable changes to this project will be documented in this file.\n\nThe format i"
},
{
"path": "embassy-embedded-hal/Cargo.toml",
"chars": 1635,
"preview": "[package]\nname = \"embassy-embedded-hal\"\nversion = \"0.6.0\"\nedition = \"2024\"\nlicense = \"MIT OR Apache-2.0\"\ndescription = \""
},
{
"path": "embassy-embedded-hal/README.md",
"chars": 553,
"preview": "# embassy-embedded-hal\n\nCollection of utilities to use `embedded-hal` and `embedded-storage` traits with Embassy.\n\n- Sha"
},
{
"path": "embassy-embedded-hal/src/adapter/blocking_async.rs",
"chars": 3948,
"preview": "/// Wrapper that implements async traits using blocking implementations.\n///\n/// This allows driver writers to depend on"
},
{
"path": "embassy-embedded-hal/src/adapter/mod.rs",
"chars": 162,
"preview": "//! Adapters between embedded-hal traits.\n\nmod blocking_async;\nmod yielding_async;\n\npub use blocking_async::BlockingAsyn"
},
{
"path": "embassy-embedded-hal/src/adapter/yielding_async.rs",
"chars": 4812,
"preview": "use embassy_futures::yield_now;\n\n/// Wrapper that yields for each operation to the wrapped instance\n///\n/// This can be "
},
{
"path": "embassy-embedded-hal/src/flash/concat_flash.rs",
"chars": 7730,
"preview": "use embedded_storage::nor_flash::{ErrorType, MultiwriteNorFlash, NorFlash, NorFlashError, ReadNorFlash};\nuse embedded_st"
},
{
"path": "embassy-embedded-hal/src/flash/mem_flash.rs",
"chars": 3616,
"preview": "use alloc::vec::Vec;\n\nuse embedded_storage::nor_flash::{ErrorType, NorFlash, ReadNorFlash};\nuse embedded_storage_async::"
},
{
"path": "embassy-embedded-hal/src/flash/mod.rs",
"chars": 145,
"preview": "//! Utilities related to flash.\n\nmod concat_flash;\n#[cfg(test)]\npub(crate) mod mem_flash;\npub mod partition;\n\npub use co"
},
{
"path": "embassy-embedded-hal/src/flash/partition/asynch.rs",
"chars": 4730,
"preview": "use embassy_sync::blocking_mutex::raw::RawMutex;\nuse embassy_sync::mutex::Mutex;\nuse embedded_storage::nor_flash::ErrorT"
},
{
"path": "embassy-embedded-hal/src/flash/partition/blocking.rs",
"chars": 4905,
"preview": "use core::cell::RefCell;\n\nuse embassy_sync::blocking_mutex::Mutex;\nuse embassy_sync::blocking_mutex::raw::RawMutex;\nuse "
},
{
"path": "embassy-embedded-hal/src/flash/partition/mod.rs",
"chars": 682,
"preview": "//! Flash Partition utilities\n\nuse embedded_storage::nor_flash::{NorFlashError, NorFlashErrorKind};\n\nmod asynch;\nmod blo"
},
{
"path": "embassy-embedded-hal/src/lib.rs",
"chars": 1364,
"preview": "#![no_std]\n#![allow(async_fn_in_trait)]\n#![warn(missing_docs)]\n#![doc = include_str!(\"../README.md\")]\n\npub mod adapter;\n"
},
{
"path": "embassy-embedded-hal/src/shared_bus/asynch/i2c.rs",
"chars": 5628,
"preview": "//! Asynchronous shared I2C bus\n//!\n//! # Example (nrf52)\n//!\n//! ```rust,ignore\n//! use embassy_embedded_hal::shared_bu"
},
{
"path": "embassy-embedded-hal/src/shared_bus/asynch/mod.rs",
"chars": 93,
"preview": "//! Asynchronous shared bus implementations for embedded-hal-async\npub mod i2c;\npub mod spi;\n"
},
{
"path": "embassy-embedded-hal/src/shared_bus/asynch/spi.rs",
"chars": 7707,
"preview": "//! Asynchronous shared SPI bus\n//!\n//! # Example (nrf52)\n//!\n//! ```rust,ignore\n//! use embassy_embedded_hal::shared_bu"
},
{
"path": "embassy-embedded-hal/src/shared_bus/blocking/i2c.rs",
"chars": 6403,
"preview": "//! Blocking shared I2C bus\n//!\n//! # Example (nrf52)\n//!\n//! ```rust,ignore\n//! use embassy_embedded_hal::shared_bus::b"
},
{
"path": "embassy-embedded-hal/src/shared_bus/blocking/mod.rs",
"chars": 83,
"preview": "//! Blocking shared bus implementations for embedded-hal\npub mod i2c;\npub mod spi;\n"
},
{
"path": "embassy-embedded-hal/src/shared_bus/blocking/spi.rs",
"chars": 6029,
"preview": "//! Blocking shared SPI bus\n//!\n//! # Example (nrf52)\n//!\n//! ```rust,ignore\n//! use embassy_embedded_hal::shared_bus::b"
},
{
"path": "embassy-embedded-hal/src/shared_bus/mod.rs",
"chars": 1606,
"preview": "//! Shared bus implementations\nuse core::fmt::Debug;\n\nuse embedded_hal_1::{i2c, spi};\n\npub mod asynch;\npub mod blocking;"
},
{
"path": "embassy-executor/CHANGELOG.md",
"chars": 6302,
"preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Change"
},
{
"path": "embassy-executor/Cargo.toml",
"chars": 11946,
"preview": "[package]\nname = \"embassy-executor\"\nversion = \"0.10.0\"\nedition = \"2024\"\nlicense = \"MIT OR Apache-2.0\"\ndescription = \"asy"
},
{
"path": "embassy-executor/README.md",
"chars": 3382,
"preview": "# embassy-executor\n\nAn async/await executor designed for embedded usage.\n\n- No `alloc`, no heap needed.\n- Tasks are stat"
},
{
"path": "embassy-executor/build.rs",
"chars": 383,
"preview": "#[path = \"./build_common.rs\"]\nmod common;\n\nfn main() {\n let mut rustc_cfgs = common::CfgSet::new();\n common::set_t"
},
{
"path": "embassy-executor/build_common.rs",
"chars": 3130,
"preview": "// NOTE: this file is copy-pasted between several Embassy crates, because there is no\n// straightforward way to share th"
},
{
"path": "embassy-executor/gen_config.py",
"chars": 2413,
"preview": "import os\n\nabspath = os.path.abspath(__file__)\ndname = os.path.dirname(abspath)\nos.chdir(dname)\n\nfeatures = []\n\n\ndef fea"
},
{
"path": "embassy-executor/src/fmt.rs",
"chars": 6494,
"preview": "#![macro_use]\n#![allow(unused)]\n\nuse core::fmt::{Debug, Display, LowerHex};\n\n#[cfg(all(feature = \"defmt\", feature = \"log"
},
{
"path": "embassy-executor/src/lib.rs",
"chars": 8071,
"preview": "#![cfg_attr(not(any(feature = \"platform-std\", feature = \"platform-wasm\")), no_std)]\n#![allow(clippy::new_without_default"
},
{
"path": "embassy-executor/src/metadata.rs",
"chars": 5143,
"preview": "#[cfg(feature = \"metadata-name\")]\nuse core::cell::Cell;\nuse core::future::{Future, poll_fn};\n#[cfg(feature = \"scheduler-"
},
{
"path": "embassy-executor/src/platform/avr.rs",
"chars": 2584,
"preview": "#[cfg(feature = \"executor-interrupt\")]\ncompile_error!(\"`executor-interrupt` is not supported with `arch-avr`.\");\n\n#[cfg("
},
{
"path": "embassy-executor/src/platform/cortex_ar.rs",
"chars": 3335,
"preview": "#[cfg(arm_profile = \"legacy\")]\ncompile_error!(\"`arch-cortex-ar` does not support the legacy ARM profile, WFE/SEV are not"
},
{
"path": "embassy-executor/src/platform/cortex_m.rs",
"chars": 9069,
"preview": "#[unsafe(export_name = \"__pender\")]\n#[cfg(any(feature = \"executor-thread\", feature = \"executor-interrupt\"))]\nfn __pender"
},
{
"path": "embassy-executor/src/platform/riscv32.rs",
"chars": 3154,
"preview": "#[cfg(feature = \"executor-interrupt\")]\ncompile_error!(\"`executor-interrupt` is not supported with `arch-riscv32`.\");\n\n#["
},
{
"path": "embassy-executor/src/platform/spin.rs",
"chars": 2007,
"preview": "#[cfg(feature = \"executor-interrupt\")]\ncompile_error!(\"`executor-interrupt` is not supported with `arch-spin`.\");\n\n#[cfg"
},
{
"path": "embassy-executor/src/platform/std.rs",
"chars": 3463,
"preview": "#[cfg(feature = \"executor-interrupt\")]\ncompile_error!(\"`executor-interrupt` is not supported with `arch-std`.\");\n\n#[cfg("
},
{
"path": "embassy-executor/src/platform/wasm.rs",
"chars": 2919,
"preview": "#[cfg(feature = \"executor-interrupt\")]\ncompile_error!(\"`executor-interrupt` is not supported with `arch-wasm`.\");\n\n#[cfg"
},
{
"path": "embassy-executor/src/raw/deadline.rs",
"chars": 1529,
"preview": "use core::sync::atomic::{AtomicU32, Ordering};\n\n/// A type for interacting with the deadline of the current task\n///\n///"
},
{
"path": "embassy-executor/src/raw/mod.rs",
"chars": 22941,
"preview": "//! Raw executor.\n//!\n//! This module exposes \"raw\" Executor and Task structs for more low level control.\n//!\n//! ## WAR"
},
{
"path": "embassy-executor/src/raw/run_queue.rs",
"chars": 8556,
"preview": "use core::ptr::{NonNull, addr_of_mut};\n\nuse cordyceps::Linked;\n#[cfg(any(feature = \"scheduler-priority\", feature = \"sche"
},
{
"path": "embassy-executor/src/raw/state_atomics.rs",
"chars": 2193,
"preview": "// Prefer pointer-width atomic operations, as narrower ones may be slower.\n#[cfg(all(target_pointer_width = \"32\", target"
},
{
"path": "embassy-executor/src/raw/state_atomics_arm.rs",
"chars": 2351,
"preview": "use core::sync::atomic::{AtomicBool, AtomicU32, Ordering, compiler_fence};\n\n#[derive(Clone, Copy)]\npub(crate) struct Tok"
},
{
"path": "embassy-executor/src/raw/state_critical_section.rs",
"chars": 2191,
"preview": "use core::cell::Cell;\n\nuse critical_section::{CriticalSection, Mutex};\npub(crate) use critical_section::{CriticalSection"
},
{
"path": "embassy-executor/src/raw/trace.rs",
"chars": 14352,
"preview": "//! # Tracing\n//!\n//! The `trace` feature enables a number of callbacks that can be used to track the\n//! lifecycle of t"
},
{
"path": "embassy-executor/src/raw/util.rs",
"chars": 1197,
"preview": "use core::cell::UnsafeCell;\nuse core::mem::MaybeUninit;\nuse core::ptr;\n\npub(crate) struct UninitCell<T>(MaybeUninit<Unsa"
},
{
"path": "embassy-executor/src/raw/waker.rs",
"chars": 1601,
"preview": "use core::task::{RawWaker, RawWakerVTable, Waker};\n\nuse super::{TaskHeader, TaskRef, wake_task};\n\nstatic VTABLE: RawWake"
},
{
"path": "embassy-executor/src/raw/waker_turbo.rs",
"chars": 1208,
"preview": "use core::ptr::NonNull;\nuse core::task::Waker;\n\nuse super::{TaskHeader, TaskRef, wake_task};\n\npub(crate) unsafe fn from_"
},
{
"path": "embassy-executor/src/spawner.rs",
"chars": 7783,
"preview": "use core::future::{Future, poll_fn};\nuse core::marker::PhantomData;\nuse core::mem;\nuse core::sync::atomic::Ordering;\nuse"
},
{
"path": "embassy-executor/tests/test.rs",
"chars": 9066,
"preview": "#![cfg_attr(feature = \"nightly\", feature(impl_trait_in_assoc_type))]\n#![cfg_attr(feature = \"nightly\", feature(never_type"
},
{
"path": "embassy-executor/tests/ui/abi.rs",
"chars": 165,
"preview": "#![cfg_attr(feature = \"nightly\", feature(impl_trait_in_assoc_type))]\n\nstruct Foo<'a>(&'a ());\n\n#[embassy_executor::task]"
},
{
"path": "embassy-executor/tests/ui/abi.stderr",
"chars": 147,
"preview": "error: task functions must not have an ABI qualifier\n --> tests/ui/abi.rs:6:1\n |\n6 | async extern \"C\" fn task() {}\n | "
},
{
"path": "embassy-executor/tests/ui/bad_return.rs",
"chars": 168,
"preview": "#![cfg_attr(feature = \"nightly\", feature(impl_trait_in_assoc_type))]\n\nstruct Foo<'a>(&'a ());\n\n#[embassy_executor::task]"
},
{
"path": "embassy-executor/tests/ui/bad_return.stderr",
"chars": 172,
"preview": "error: task functions must either not return a value, return `()` or return `!`\n --> tests/ui/bad_return.rs:6:1\n |\n6 | "
},
{
"path": "embassy-executor/tests/ui/bad_return_impl_future.rs",
"chars": 195,
"preview": "#![cfg_attr(feature = \"nightly\", feature(impl_trait_in_assoc_type))]\nuse core::future::Future;\n\n#[embassy_executor::task"
},
{
"path": "embassy-executor/tests/ui/bad_return_impl_future.stderr",
"chars": 5857,
"preview": "error[E0277]: task futures must resolve to `()` or `!`\n --> tests/ui/bad_return_impl_future.rs:5:4\n |\n4 | #[embassy_exe"
},
{
"path": "embassy-executor/tests/ui/bad_return_impl_future_nightly.rs",
"chars": 195,
"preview": "#![cfg_attr(feature = \"nightly\", feature(impl_trait_in_assoc_type))]\nuse core::future::Future;\n\n#[embassy_executor::task"
},
{
"path": "embassy-executor/tests/ui/bad_return_impl_future_nightly.stderr",
"chars": 595,
"preview": "error[E0277]: task futures must resolve to `()` or `!`\n --> tests/ui/bad_return_impl_future_nightly.rs:4:1\n |\n4 | #[emb"
},
{
"path": "embassy-executor/tests/ui/generics.rs",
"chars": 169,
"preview": "#![cfg_attr(feature = \"nightly\", feature(impl_trait_in_assoc_type))]\n\nstruct Foo<'a>(&'a ());\n\n#[embassy_executor::task]"
},
{
"path": "embassy-executor/tests/ui/generics.stderr",
"chars": 149,
"preview": "error: task functions must not be generic\n --> tests/ui/generics.rs:6:1\n |\n6 | async fn task<T: Sized>(_t: T) {}\n | ^^"
},
{
"path": "embassy-executor/tests/ui/impl_trait.rs",
"chars": 142,
"preview": "#![cfg_attr(feature = \"nightly\", feature(impl_trait_in_assoc_type))]\n\n#[embassy_executor::task]\nasync fn foo(_x: impl Si"
},
{
"path": "embassy-executor/tests/ui/impl_trait.stderr",
"chars": 220,
"preview": "error: `impl Trait` is not allowed in task arguments. It is syntax sugar for generics, and tasks can't be generic.\n --> "
},
{
"path": "embassy-executor/tests/ui/impl_trait_nested.rs",
"chars": 176,
"preview": "#![cfg_attr(feature = \"nightly\", feature(impl_trait_in_assoc_type))]\n\nstruct Foo<T>(T);\n\n#[embassy_executor::task]\nasync"
},
{
"path": "embassy-executor/tests/ui/impl_trait_nested.stderr",
"chars": 256,
"preview": "error: `impl Trait` is not allowed in task arguments. It is syntax sugar for generics, and tasks can't be generic.\n --> "
},
{
"path": "embassy-executor/tests/ui/impl_trait_static.rs",
"chars": 152,
"preview": "#![cfg_attr(feature = \"nightly\", feature(impl_trait_in_assoc_type))]\n\n#[embassy_executor::task]\nasync fn foo(_x: impl Si"
},
{
"path": "embassy-executor/tests/ui/impl_trait_static.stderr",
"chars": 247,
"preview": "error: `impl Trait` is not allowed in task arguments. It is syntax sugar for generics, and tasks can't be generic.\n --> "
},
{
"path": "embassy-executor/tests/ui/nonstatic_ref_anon.rs",
"chars": 139,
"preview": "#![cfg_attr(feature = \"nightly\", feature(impl_trait_in_assoc_type))]\n\n#[embassy_executor::task]\nasync fn foo(_x: &'_ u32"
},
{
"path": "embassy-executor/tests/ui/nonstatic_ref_anon.stderr",
"chars": 183,
"preview": "error: Arguments for tasks must live forever. Try using the `'static` lifetime.\n --> tests/ui/nonstatic_ref_anon.rs:4:19"
},
{
"path": "embassy-executor/tests/ui/nonstatic_ref_anon_nested.rs",
"chars": 148,
"preview": "#![cfg_attr(feature = \"nightly\", feature(impl_trait_in_assoc_type))]\n\n#[embassy_executor::task]\nasync fn foo(_x: &'stati"
},
{
"path": "embassy-executor/tests/ui/nonstatic_ref_anon_nested.stderr",
"chars": 208,
"preview": "error: Arguments for tasks must live forever. Try using the `'static` lifetime.\n --> tests/ui/nonstatic_ref_anon_nested."
},
{
"path": "embassy-executor/tests/ui/nonstatic_ref_elided.rs",
"chars": 136,
"preview": "#![cfg_attr(feature = \"nightly\", feature(impl_trait_in_assoc_type))]\n\n#[embassy_executor::task]\nasync fn foo(_x: &u32) {"
},
{
"path": "embassy-executor/tests/ui/nonstatic_ref_elided.stderr",
"chars": 180,
"preview": "error: Arguments for tasks must live forever. Try using the `'static` lifetime.\n --> tests/ui/nonstatic_ref_elided.rs:4:"
},
{
"path": "embassy-executor/tests/ui/nonstatic_ref_generic.rs",
"chars": 143,
"preview": "#![cfg_attr(feature = \"nightly\", feature(impl_trait_in_assoc_type))]\n\n#[embassy_executor::task]\nasync fn foo<'a>(_x: &'a"
},
{
"path": "embassy-executor/tests/ui/nonstatic_ref_generic.stderr",
"chars": 355,
"preview": "error: task functions must not be generic\n --> tests/ui/nonstatic_ref_generic.rs:4:1\n |\n4 | async fn foo<'a>(_x: &'a u3"
}
]
// ... and 2145 more files (download for full content)
About this extraction
This page contains the full source code of the embassy-rs/embassy GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 2345 files (12.5 MB), approximately 3.4M tokens, and a symbol index with 23404 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.