atsamd_hal/sercom/spi/impl_ehal/
panic_on.rs

1//! [`SpiBus`] implementations for [`PanicOnWrite`] and [`PanicOnRead`]
2
3use num_traits::{AsPrimitive, PrimInt};
4
5use crate::ehal::spi::{ErrorType, SpiBus};
6
7use super::{
8    Config, DataWidth, MasterMode, PanicOnRead, PanicOnWrite, Rx, Size, Spi, Tx, ValidConfig,
9    ValidPads, Word,
10};
11
12impl<T: ErrorType> ErrorType for PanicOnRead<T> {
13    type Error = <T as ErrorType>::Error;
14}
15
16impl<T: ErrorType> ErrorType for PanicOnWrite<T> {
17    type Error = <T as ErrorType>::Error;
18}
19
20/// [`SpiBus`] implementation for [`PanicOnRead`] using word-by-word transfers
21impl<P, M, C> SpiBus<Word<C>> for PanicOnRead<Spi<Config<P, M, C>, Tx>>
22where
23    Config<P, M, C>: ValidConfig<OpMode = M>,
24    P: ValidPads,
25    M: MasterMode,
26    C: Size + 'static,
27    C::Word: PrimInt + AsPrimitive<DataWidth> + Copy,
28    DataWidth: AsPrimitive<C::Word>,
29{
30    #[inline]
31    fn read(&mut self, _words: &mut [Word<C>]) -> Result<(), Self::Error> {
32        unimplemented!("`PanicOnRead` panics on SPI reads");
33    }
34
35    #[inline]
36    fn write(&mut self, words: &[Word<C>]) -> Result<(), Self::Error> {
37        self.0.write_word_by_word(words)
38    }
39
40    #[inline]
41    fn transfer(&mut self, _read: &mut [Word<C>], _write: &[Word<C>]) -> Result<(), Self::Error> {
42        unimplemented!("`PanicOnRead` panics on SPI reads");
43    }
44
45    #[inline]
46    fn transfer_in_place(&mut self, _words: &mut [Word<C>]) -> Result<(), Self::Error> {
47        unimplemented!("`PanicOnRead` panics on SPI reads");
48    }
49
50    #[inline]
51    fn flush(&mut self) -> Result<(), Self::Error> {
52        self.0.flush_tx();
53        Ok(())
54    }
55}
56
57/// [`SpiBus`] implementation for [`PanicOnWrite`] using word-by-word transfers
58impl<P, M, C> SpiBus<Word<C>> for PanicOnWrite<Spi<Config<P, M, C>, Rx>>
59where
60    Config<P, M, C>: ValidConfig<OpMode = M>,
61    P: ValidPads,
62    M: MasterMode,
63    C: Size + 'static,
64    C::Word: PrimInt + AsPrimitive<DataWidth> + Copy,
65    DataWidth: AsPrimitive<C::Word>,
66{
67    #[inline]
68    fn read(&mut self, words: &mut [Word<C>]) -> Result<(), Self::Error> {
69        self.0.read_word_by_word(words)
70    }
71
72    #[inline]
73    fn write(&mut self, _words: &[Word<C>]) -> Result<(), Self::Error> {
74        unimplemented!("`PanicOnWrite` panics on SPI writes");
75    }
76
77    #[inline]
78    fn transfer(&mut self, _read: &mut [Word<C>], _write: &[Word<C>]) -> Result<(), Self::Error> {
79        unimplemented!("`PanicOnWrite` panics on SPI writes");
80    }
81
82    #[inline]
83    fn transfer_in_place(&mut self, _words: &mut [Word<C>]) -> Result<(), Self::Error> {
84        unimplemented!("`PanicOnWrite` panics on SPI writes");
85    }
86
87    #[inline]
88    fn flush(&mut self) -> Result<(), Self::Error> {
89        unimplemented!("`PanicOnWrite` panics on SPI writes");
90    }
91}
92
93#[cfg(feature = "dma")]
94mod dma {
95    use super::*;
96    use crate::dmac::{AnyChannel, Beat, Ready};
97    use crate::sercom::Sercom;
98    use crate::typelevel::NoneT;
99
100    /// [`SpiBus`] implementation for [`PanicOnRead`] using DMA transfers
101    impl<P, M, C, T, S> SpiBus<Word<C>> for PanicOnRead<Spi<Config<P, M, C>, Tx, NoneT, T>>
102    where
103        Config<P, M, C>: ValidConfig<Sercom = S, OpMode = M>,
104        P: ValidPads,
105        M: MasterMode,
106        C: Size + 'static,
107        C::Word: PrimInt + AsPrimitive<DataWidth> + Beat,
108        S: Sercom,
109        DataWidth: AsPrimitive<C::Word>,
110        T: AnyChannel<Status = Ready>,
111    {
112        #[inline]
113        fn read(&mut self, _words: &mut [Word<C>]) -> Result<(), Self::Error> {
114            unimplemented!("`PanicOnRead` panics on SPI reads");
115        }
116
117        #[inline]
118        fn write(&mut self, words: &[Word<C>]) -> Result<(), Self::Error> {
119            self.0.write_dma(words)?;
120            Ok(())
121        }
122
123        #[inline]
124        fn transfer(
125            &mut self,
126            _read: &mut [Word<C>],
127            _write: &[Word<C>],
128        ) -> Result<(), Self::Error> {
129            unimplemented!("`PanicOnRead` panics on SPI reads");
130        }
131
132        #[inline]
133        fn transfer_in_place(&mut self, _words: &mut [Word<C>]) -> Result<(), Self::Error> {
134            unimplemented!("`PanicOnRead` panics on SPI reads");
135        }
136
137        #[inline]
138        fn flush(&mut self) -> Result<(), Self::Error> {
139            self.0.flush_tx();
140            Ok(())
141        }
142    }
143
144    /// [`SpiBus`] implementation for [`PanicOnWrite`] using DMA transfers
145    impl<P, M, C, R, T> SpiBus<Word<C>> for PanicOnWrite<Spi<Config<P, M, C>, Rx, R, T>>
146    where
147        Config<P, M, C>: ValidConfig<OpMode = M>,
148        P: ValidPads,
149        M: MasterMode,
150        C: Size + 'static,
151        C::Word: PrimInt + AsPrimitive<DataWidth> + Beat,
152        DataWidth: AsPrimitive<C::Word>,
153        R: AnyChannel<Status = Ready>,
154        T: AnyChannel<Status = Ready>,
155    {
156        #[inline]
157        fn read(&mut self, words: &mut [Word<C>]) -> Result<(), Self::Error> {
158            self.0.read_dma_master(words)
159        }
160
161        #[inline]
162        fn write(&mut self, _words: &[Word<C>]) -> Result<(), Self::Error> {
163            unimplemented!("`PanicOnWrite` panics on SPI writes");
164        }
165
166        #[inline]
167        fn transfer(
168            &mut self,
169            _read: &mut [Word<C>],
170            _write: &[Word<C>],
171        ) -> Result<(), Self::Error> {
172            unimplemented!("`PanicOnWrite` panics on SPI writes");
173        }
174
175        #[inline]
176        fn transfer_in_place(&mut self, _words: &mut [Word<C>]) -> Result<(), Self::Error> {
177            unimplemented!("`PanicOnWrite` panics on SPI writes");
178        }
179
180        #[inline]
181        fn flush(&mut self) -> Result<(), Self::Error> {
182            unimplemented!("`PanicOnWrite` panics on SPI writes");
183        }
184    }
185}