py32_hal/
dma.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
//! Direct Memory Access (DMA)
#![macro_use]
#![warn(dead_code)]

// #[cfg(any(bdma, dma))]
// mod dma_bdma;
// #[cfg(any(bdma, dma))]
// pub use dma_bdma::*;

// #[cfg(gpdma)]
// pub(crate) mod gpdma;
// #[cfg(gpdma)]
// pub use gpdma::*;

// #[cfg(dmamux)]
// mod dmamux;
// #[cfg(dmamux)]
// pub(crate) use dmamux::*;

// mod util;
// pub(crate) use util::*;

// pub(crate) mod ringbuffer;
// pub mod word;

use embassy_hal_internal::{impl_peripheral, Peripheral};

// #[derive(Debug, Copy, Clone, PartialEq, Eq)]
// #[cfg_attr(feature = "defmt", derive(defmt::Format))]
// enum Dir {
//     MemoryToPeripheral,
//     PeripheralToMemory,
// }

// /// DMA request type alias. (also known as DMA channel number in some chips)
// #[cfg(any(dma_v2, bdma_v2, gpdma, dmamux))]
// pub type Request = u8;
// /// DMA request type alias. (also known as DMA channel number in some chips)
// #[cfg(not(any(dma_v2, bdma_v2, gpdma, dmamux)))]
pub type Request = ();

pub(crate) trait SealedChannel {
    fn id(&self) -> u8;
}

// pub(crate) trait ChannelInterrupt {
//     #[cfg_attr(not(feature = "rt"), allow(unused))]
//     unsafe fn on_irq();
// }

/// DMA channel.
#[allow(private_bounds)]
pub trait Channel: SealedChannel + Peripheral<P = Self> + Into<AnyChannel> + 'static {
    /// Type-erase (degrade) this pin into an `AnyChannel`.
    ///
    /// This converts DMA channel singletons (`DMA1_CH3`, `DMA2_CH1`, ...), which
    /// are all different types, into the same type. It is useful for
    /// creating arrays of channels, or avoiding generics.
    #[inline]
    fn degrade(self) -> AnyChannel {
        AnyChannel { id: self.id() }
    }
}

// macro_rules! dma_channel_impl {
//     ($channel_peri:ident, $index:expr) => {
//         impl crate::dma::SealedChannel for crate::peripherals::$channel_peri {
//             fn id(&self) -> u8 {
//                 $index
//             }
//         }
//         impl crate::dma::ChannelInterrupt for crate::peripherals::$channel_peri {
//             unsafe fn on_irq() {
//                 crate::dma::AnyChannel { id: $index }.on_irq();
//             }
//         }

//         impl crate::dma::Channel for crate::peripherals::$channel_peri {}

//         impl From<crate::peripherals::$channel_peri> for crate::dma::AnyChannel {
//             fn from(x: crate::peripherals::$channel_peri) -> Self {
//                 crate::dma::Channel::degrade(x)
//             }
//         }
//     };
// }

/// Type-erased DMA channel.
pub struct AnyChannel {
    pub(crate) id: u8,
}
impl_peripheral!(AnyChannel);

// impl AnyChannel {
//     fn info(&self) -> &ChannelInfo {
//         &crate::_generated::DMA_CHANNELS[self.id as usize]
//     }
// }

impl SealedChannel for AnyChannel {
    fn id(&self) -> u8 {
        self.id
    }
}
impl Channel for AnyChannel {}

// const CHANNEL_COUNT: usize = crate::_generated::DMA_CHANNELS.len();
// static STATE: [ChannelState; CHANNEL_COUNT] = [ChannelState::NEW; CHANNEL_COUNT];

/// "No DMA" placeholder.
///
/// You may pass this in place of a real DMA channel when creating a driver
/// to indicate it should not use DMA.
///
/// This often causes async functionality to not be available on the instance,
/// leaving only blocking functionality.
pub struct NoDma;

impl_peripheral!(NoDma);

// // safety: must be called only once at startup
// pub(crate) unsafe fn init(
//     cs: critical_section::CriticalSection,
//     #[cfg(bdma)] bdma_priority: interrupt::Priority,
//     #[cfg(dma)] dma_priority: interrupt::Priority,
//     #[cfg(gpdma)] gpdma_priority: interrupt::Priority,
// ) {
//     #[cfg(any(dma, bdma))]
//     dma_bdma::init(
//         cs,
//         #[cfg(dma)]
//         dma_priority,
//         #[cfg(bdma)]
//         bdma_priority,
//     );
//     #[cfg(gpdma)]
//     gpdma::init(cs, gpdma_priority);
//     #[cfg(dmamux)]
//     dmamux::init(cs);
// }