stm32l4x2_pac/spi1/
cr2.rs

1#[doc = r" Value read from the register"]
2pub struct R {
3    bits: u32,
4}
5#[doc = r" Value to write to the register"]
6pub struct W {
7    bits: u32,
8}
9impl super::CR2 {
10    #[doc = r" Modifies the contents of the register"]
11    #[inline]
12    pub fn modify<F>(&self, f: F)
13    where
14        for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
15    {
16        let bits = self.register.get();
17        let r = R { bits: bits };
18        let mut w = W { bits: bits };
19        f(&r, &mut w);
20        self.register.set(w.bits);
21    }
22    #[doc = r" Reads the contents of the register"]
23    #[inline]
24    pub fn read(&self) -> R {
25        R {
26            bits: self.register.get(),
27        }
28    }
29    #[doc = r" Writes to the register"]
30    #[inline]
31    pub fn write<F>(&self, f: F)
32    where
33        F: FnOnce(&mut W) -> &mut W,
34    {
35        let mut w = W::reset_value();
36        f(&mut w);
37        self.register.set(w.bits);
38    }
39    #[doc = r" Writes the reset value to the register"]
40    #[inline]
41    pub fn reset(&self) {
42        self.write(|w| w)
43    }
44}
45#[doc = r" Value of the field"]
46pub struct RXDMAENR {
47    bits: bool,
48}
49impl RXDMAENR {
50    #[doc = r" Value of the field as raw bits"]
51    #[inline]
52    pub fn bit(&self) -> bool {
53        self.bits
54    }
55    #[doc = r" Returns `true` if the bit is clear (0)"]
56    #[inline]
57    pub fn bit_is_clear(&self) -> bool {
58        !self.bit()
59    }
60    #[doc = r" Returns `true` if the bit is set (1)"]
61    #[inline]
62    pub fn bit_is_set(&self) -> bool {
63        self.bit()
64    }
65}
66#[doc = r" Value of the field"]
67pub struct TXDMAENR {
68    bits: bool,
69}
70impl TXDMAENR {
71    #[doc = r" Value of the field as raw bits"]
72    #[inline]
73    pub fn bit(&self) -> bool {
74        self.bits
75    }
76    #[doc = r" Returns `true` if the bit is clear (0)"]
77    #[inline]
78    pub fn bit_is_clear(&self) -> bool {
79        !self.bit()
80    }
81    #[doc = r" Returns `true` if the bit is set (1)"]
82    #[inline]
83    pub fn bit_is_set(&self) -> bool {
84        self.bit()
85    }
86}
87#[doc = r" Value of the field"]
88pub struct SSOER {
89    bits: bool,
90}
91impl SSOER {
92    #[doc = r" Value of the field as raw bits"]
93    #[inline]
94    pub fn bit(&self) -> bool {
95        self.bits
96    }
97    #[doc = r" Returns `true` if the bit is clear (0)"]
98    #[inline]
99    pub fn bit_is_clear(&self) -> bool {
100        !self.bit()
101    }
102    #[doc = r" Returns `true` if the bit is set (1)"]
103    #[inline]
104    pub fn bit_is_set(&self) -> bool {
105        self.bit()
106    }
107}
108#[doc = r" Value of the field"]
109pub struct NSSPR {
110    bits: bool,
111}
112impl NSSPR {
113    #[doc = r" Value of the field as raw bits"]
114    #[inline]
115    pub fn bit(&self) -> bool {
116        self.bits
117    }
118    #[doc = r" Returns `true` if the bit is clear (0)"]
119    #[inline]
120    pub fn bit_is_clear(&self) -> bool {
121        !self.bit()
122    }
123    #[doc = r" Returns `true` if the bit is set (1)"]
124    #[inline]
125    pub fn bit_is_set(&self) -> bool {
126        self.bit()
127    }
128}
129#[doc = r" Value of the field"]
130pub struct FRFR {
131    bits: bool,
132}
133impl FRFR {
134    #[doc = r" Value of the field as raw bits"]
135    #[inline]
136    pub fn bit(&self) -> bool {
137        self.bits
138    }
139    #[doc = r" Returns `true` if the bit is clear (0)"]
140    #[inline]
141    pub fn bit_is_clear(&self) -> bool {
142        !self.bit()
143    }
144    #[doc = r" Returns `true` if the bit is set (1)"]
145    #[inline]
146    pub fn bit_is_set(&self) -> bool {
147        self.bit()
148    }
149}
150#[doc = r" Value of the field"]
151pub struct ERRIER {
152    bits: bool,
153}
154impl ERRIER {
155    #[doc = r" Value of the field as raw bits"]
156    #[inline]
157    pub fn bit(&self) -> bool {
158        self.bits
159    }
160    #[doc = r" Returns `true` if the bit is clear (0)"]
161    #[inline]
162    pub fn bit_is_clear(&self) -> bool {
163        !self.bit()
164    }
165    #[doc = r" Returns `true` if the bit is set (1)"]
166    #[inline]
167    pub fn bit_is_set(&self) -> bool {
168        self.bit()
169    }
170}
171#[doc = r" Value of the field"]
172pub struct RXNEIER {
173    bits: bool,
174}
175impl RXNEIER {
176    #[doc = r" Value of the field as raw bits"]
177    #[inline]
178    pub fn bit(&self) -> bool {
179        self.bits
180    }
181    #[doc = r" Returns `true` if the bit is clear (0)"]
182    #[inline]
183    pub fn bit_is_clear(&self) -> bool {
184        !self.bit()
185    }
186    #[doc = r" Returns `true` if the bit is set (1)"]
187    #[inline]
188    pub fn bit_is_set(&self) -> bool {
189        self.bit()
190    }
191}
192#[doc = r" Value of the field"]
193pub struct TXEIER {
194    bits: bool,
195}
196impl TXEIER {
197    #[doc = r" Value of the field as raw bits"]
198    #[inline]
199    pub fn bit(&self) -> bool {
200        self.bits
201    }
202    #[doc = r" Returns `true` if the bit is clear (0)"]
203    #[inline]
204    pub fn bit_is_clear(&self) -> bool {
205        !self.bit()
206    }
207    #[doc = r" Returns `true` if the bit is set (1)"]
208    #[inline]
209    pub fn bit_is_set(&self) -> bool {
210        self.bit()
211    }
212}
213#[doc = r" Value of the field"]
214pub struct DSR {
215    bits: u8,
216}
217impl DSR {
218    #[doc = r" Value of the field as raw bits"]
219    #[inline]
220    pub fn bits(&self) -> u8 {
221        self.bits
222    }
223}
224#[doc = r" Value of the field"]
225pub struct FRXTHR {
226    bits: bool,
227}
228impl FRXTHR {
229    #[doc = r" Value of the field as raw bits"]
230    #[inline]
231    pub fn bit(&self) -> bool {
232        self.bits
233    }
234    #[doc = r" Returns `true` if the bit is clear (0)"]
235    #[inline]
236    pub fn bit_is_clear(&self) -> bool {
237        !self.bit()
238    }
239    #[doc = r" Returns `true` if the bit is set (1)"]
240    #[inline]
241    pub fn bit_is_set(&self) -> bool {
242        self.bit()
243    }
244}
245#[doc = r" Value of the field"]
246pub struct LDMA_RXR {
247    bits: bool,
248}
249impl LDMA_RXR {
250    #[doc = r" Value of the field as raw bits"]
251    #[inline]
252    pub fn bit(&self) -> bool {
253        self.bits
254    }
255    #[doc = r" Returns `true` if the bit is clear (0)"]
256    #[inline]
257    pub fn bit_is_clear(&self) -> bool {
258        !self.bit()
259    }
260    #[doc = r" Returns `true` if the bit is set (1)"]
261    #[inline]
262    pub fn bit_is_set(&self) -> bool {
263        self.bit()
264    }
265}
266#[doc = r" Value of the field"]
267pub struct LDMA_TXR {
268    bits: bool,
269}
270impl LDMA_TXR {
271    #[doc = r" Value of the field as raw bits"]
272    #[inline]
273    pub fn bit(&self) -> bool {
274        self.bits
275    }
276    #[doc = r" Returns `true` if the bit is clear (0)"]
277    #[inline]
278    pub fn bit_is_clear(&self) -> bool {
279        !self.bit()
280    }
281    #[doc = r" Returns `true` if the bit is set (1)"]
282    #[inline]
283    pub fn bit_is_set(&self) -> bool {
284        self.bit()
285    }
286}
287#[doc = r" Proxy"]
288pub struct _RXDMAENW<'a> {
289    w: &'a mut W,
290}
291impl<'a> _RXDMAENW<'a> {
292    #[doc = r" Sets the field bit"]
293    pub fn set_bit(self) -> &'a mut W {
294        self.bit(true)
295    }
296    #[doc = r" Clears the field bit"]
297    pub fn clear_bit(self) -> &'a mut W {
298        self.bit(false)
299    }
300    #[doc = r" Writes raw bits to the field"]
301    #[inline]
302    pub fn bit(self, value: bool) -> &'a mut W {
303        const MASK: bool = true;
304        const OFFSET: u8 = 0;
305        self.w.bits &= !((MASK as u32) << OFFSET);
306        self.w.bits |= ((value & MASK) as u32) << OFFSET;
307        self.w
308    }
309}
310#[doc = r" Proxy"]
311pub struct _TXDMAENW<'a> {
312    w: &'a mut W,
313}
314impl<'a> _TXDMAENW<'a> {
315    #[doc = r" Sets the field bit"]
316    pub fn set_bit(self) -> &'a mut W {
317        self.bit(true)
318    }
319    #[doc = r" Clears the field bit"]
320    pub fn clear_bit(self) -> &'a mut W {
321        self.bit(false)
322    }
323    #[doc = r" Writes raw bits to the field"]
324    #[inline]
325    pub fn bit(self, value: bool) -> &'a mut W {
326        const MASK: bool = true;
327        const OFFSET: u8 = 1;
328        self.w.bits &= !((MASK as u32) << OFFSET);
329        self.w.bits |= ((value & MASK) as u32) << OFFSET;
330        self.w
331    }
332}
333#[doc = r" Proxy"]
334pub struct _SSOEW<'a> {
335    w: &'a mut W,
336}
337impl<'a> _SSOEW<'a> {
338    #[doc = r" Sets the field bit"]
339    pub fn set_bit(self) -> &'a mut W {
340        self.bit(true)
341    }
342    #[doc = r" Clears the field bit"]
343    pub fn clear_bit(self) -> &'a mut W {
344        self.bit(false)
345    }
346    #[doc = r" Writes raw bits to the field"]
347    #[inline]
348    pub fn bit(self, value: bool) -> &'a mut W {
349        const MASK: bool = true;
350        const OFFSET: u8 = 2;
351        self.w.bits &= !((MASK as u32) << OFFSET);
352        self.w.bits |= ((value & MASK) as u32) << OFFSET;
353        self.w
354    }
355}
356#[doc = r" Proxy"]
357pub struct _NSSPW<'a> {
358    w: &'a mut W,
359}
360impl<'a> _NSSPW<'a> {
361    #[doc = r" Sets the field bit"]
362    pub fn set_bit(self) -> &'a mut W {
363        self.bit(true)
364    }
365    #[doc = r" Clears the field bit"]
366    pub fn clear_bit(self) -> &'a mut W {
367        self.bit(false)
368    }
369    #[doc = r" Writes raw bits to the field"]
370    #[inline]
371    pub fn bit(self, value: bool) -> &'a mut W {
372        const MASK: bool = true;
373        const OFFSET: u8 = 3;
374        self.w.bits &= !((MASK as u32) << OFFSET);
375        self.w.bits |= ((value & MASK) as u32) << OFFSET;
376        self.w
377    }
378}
379#[doc = r" Proxy"]
380pub struct _FRFW<'a> {
381    w: &'a mut W,
382}
383impl<'a> _FRFW<'a> {
384    #[doc = r" Sets the field bit"]
385    pub fn set_bit(self) -> &'a mut W {
386        self.bit(true)
387    }
388    #[doc = r" Clears the field bit"]
389    pub fn clear_bit(self) -> &'a mut W {
390        self.bit(false)
391    }
392    #[doc = r" Writes raw bits to the field"]
393    #[inline]
394    pub fn bit(self, value: bool) -> &'a mut W {
395        const MASK: bool = true;
396        const OFFSET: u8 = 4;
397        self.w.bits &= !((MASK as u32) << OFFSET);
398        self.w.bits |= ((value & MASK) as u32) << OFFSET;
399        self.w
400    }
401}
402#[doc = r" Proxy"]
403pub struct _ERRIEW<'a> {
404    w: &'a mut W,
405}
406impl<'a> _ERRIEW<'a> {
407    #[doc = r" Sets the field bit"]
408    pub fn set_bit(self) -> &'a mut W {
409        self.bit(true)
410    }
411    #[doc = r" Clears the field bit"]
412    pub fn clear_bit(self) -> &'a mut W {
413        self.bit(false)
414    }
415    #[doc = r" Writes raw bits to the field"]
416    #[inline]
417    pub fn bit(self, value: bool) -> &'a mut W {
418        const MASK: bool = true;
419        const OFFSET: u8 = 5;
420        self.w.bits &= !((MASK as u32) << OFFSET);
421        self.w.bits |= ((value & MASK) as u32) << OFFSET;
422        self.w
423    }
424}
425#[doc = r" Proxy"]
426pub struct _RXNEIEW<'a> {
427    w: &'a mut W,
428}
429impl<'a> _RXNEIEW<'a> {
430    #[doc = r" Sets the field bit"]
431    pub fn set_bit(self) -> &'a mut W {
432        self.bit(true)
433    }
434    #[doc = r" Clears the field bit"]
435    pub fn clear_bit(self) -> &'a mut W {
436        self.bit(false)
437    }
438    #[doc = r" Writes raw bits to the field"]
439    #[inline]
440    pub fn bit(self, value: bool) -> &'a mut W {
441        const MASK: bool = true;
442        const OFFSET: u8 = 6;
443        self.w.bits &= !((MASK as u32) << OFFSET);
444        self.w.bits |= ((value & MASK) as u32) << OFFSET;
445        self.w
446    }
447}
448#[doc = r" Proxy"]
449pub struct _TXEIEW<'a> {
450    w: &'a mut W,
451}
452impl<'a> _TXEIEW<'a> {
453    #[doc = r" Sets the field bit"]
454    pub fn set_bit(self) -> &'a mut W {
455        self.bit(true)
456    }
457    #[doc = r" Clears the field bit"]
458    pub fn clear_bit(self) -> &'a mut W {
459        self.bit(false)
460    }
461    #[doc = r" Writes raw bits to the field"]
462    #[inline]
463    pub fn bit(self, value: bool) -> &'a mut W {
464        const MASK: bool = true;
465        const OFFSET: u8 = 7;
466        self.w.bits &= !((MASK as u32) << OFFSET);
467        self.w.bits |= ((value & MASK) as u32) << OFFSET;
468        self.w
469    }
470}
471#[doc = r" Proxy"]
472pub struct _DSW<'a> {
473    w: &'a mut W,
474}
475impl<'a> _DSW<'a> {
476    #[doc = r" Writes raw bits to the field"]
477    #[inline]
478    pub unsafe fn bits(self, value: u8) -> &'a mut W {
479        const MASK: u8 = 15;
480        const OFFSET: u8 = 8;
481        self.w.bits &= !((MASK as u32) << OFFSET);
482        self.w.bits |= ((value & MASK) as u32) << OFFSET;
483        self.w
484    }
485}
486#[doc = r" Proxy"]
487pub struct _FRXTHW<'a> {
488    w: &'a mut W,
489}
490impl<'a> _FRXTHW<'a> {
491    #[doc = r" Sets the field bit"]
492    pub fn set_bit(self) -> &'a mut W {
493        self.bit(true)
494    }
495    #[doc = r" Clears the field bit"]
496    pub fn clear_bit(self) -> &'a mut W {
497        self.bit(false)
498    }
499    #[doc = r" Writes raw bits to the field"]
500    #[inline]
501    pub fn bit(self, value: bool) -> &'a mut W {
502        const MASK: bool = true;
503        const OFFSET: u8 = 12;
504        self.w.bits &= !((MASK as u32) << OFFSET);
505        self.w.bits |= ((value & MASK) as u32) << OFFSET;
506        self.w
507    }
508}
509#[doc = r" Proxy"]
510pub struct _LDMA_RXW<'a> {
511    w: &'a mut W,
512}
513impl<'a> _LDMA_RXW<'a> {
514    #[doc = r" Sets the field bit"]
515    pub fn set_bit(self) -> &'a mut W {
516        self.bit(true)
517    }
518    #[doc = r" Clears the field bit"]
519    pub fn clear_bit(self) -> &'a mut W {
520        self.bit(false)
521    }
522    #[doc = r" Writes raw bits to the field"]
523    #[inline]
524    pub fn bit(self, value: bool) -> &'a mut W {
525        const MASK: bool = true;
526        const OFFSET: u8 = 13;
527        self.w.bits &= !((MASK as u32) << OFFSET);
528        self.w.bits |= ((value & MASK) as u32) << OFFSET;
529        self.w
530    }
531}
532#[doc = r" Proxy"]
533pub struct _LDMA_TXW<'a> {
534    w: &'a mut W,
535}
536impl<'a> _LDMA_TXW<'a> {
537    #[doc = r" Sets the field bit"]
538    pub fn set_bit(self) -> &'a mut W {
539        self.bit(true)
540    }
541    #[doc = r" Clears the field bit"]
542    pub fn clear_bit(self) -> &'a mut W {
543        self.bit(false)
544    }
545    #[doc = r" Writes raw bits to the field"]
546    #[inline]
547    pub fn bit(self, value: bool) -> &'a mut W {
548        const MASK: bool = true;
549        const OFFSET: u8 = 14;
550        self.w.bits &= !((MASK as u32) << OFFSET);
551        self.w.bits |= ((value & MASK) as u32) << OFFSET;
552        self.w
553    }
554}
555impl R {
556    #[doc = r" Value of the register as raw bits"]
557    #[inline]
558    pub fn bits(&self) -> u32 {
559        self.bits
560    }
561    #[doc = "Bit 0 - Rx buffer DMA enable"]
562    #[inline]
563    pub fn rxdmaen(&self) -> RXDMAENR {
564        let bits = {
565            const MASK: bool = true;
566            const OFFSET: u8 = 0;
567            ((self.bits >> OFFSET) & MASK as u32) != 0
568        };
569        RXDMAENR { bits }
570    }
571    #[doc = "Bit 1 - Tx buffer DMA enable"]
572    #[inline]
573    pub fn txdmaen(&self) -> TXDMAENR {
574        let bits = {
575            const MASK: bool = true;
576            const OFFSET: u8 = 1;
577            ((self.bits >> OFFSET) & MASK as u32) != 0
578        };
579        TXDMAENR { bits }
580    }
581    #[doc = "Bit 2 - SS output enable"]
582    #[inline]
583    pub fn ssoe(&self) -> SSOER {
584        let bits = {
585            const MASK: bool = true;
586            const OFFSET: u8 = 2;
587            ((self.bits >> OFFSET) & MASK as u32) != 0
588        };
589        SSOER { bits }
590    }
591    #[doc = "Bit 3 - NSS pulse management"]
592    #[inline]
593    pub fn nssp(&self) -> NSSPR {
594        let bits = {
595            const MASK: bool = true;
596            const OFFSET: u8 = 3;
597            ((self.bits >> OFFSET) & MASK as u32) != 0
598        };
599        NSSPR { bits }
600    }
601    #[doc = "Bit 4 - Frame format"]
602    #[inline]
603    pub fn frf(&self) -> FRFR {
604        let bits = {
605            const MASK: bool = true;
606            const OFFSET: u8 = 4;
607            ((self.bits >> OFFSET) & MASK as u32) != 0
608        };
609        FRFR { bits }
610    }
611    #[doc = "Bit 5 - Error interrupt enable"]
612    #[inline]
613    pub fn errie(&self) -> ERRIER {
614        let bits = {
615            const MASK: bool = true;
616            const OFFSET: u8 = 5;
617            ((self.bits >> OFFSET) & MASK as u32) != 0
618        };
619        ERRIER { bits }
620    }
621    #[doc = "Bit 6 - RX buffer not empty interrupt enable"]
622    #[inline]
623    pub fn rxneie(&self) -> RXNEIER {
624        let bits = {
625            const MASK: bool = true;
626            const OFFSET: u8 = 6;
627            ((self.bits >> OFFSET) & MASK as u32) != 0
628        };
629        RXNEIER { bits }
630    }
631    #[doc = "Bit 7 - Tx buffer empty interrupt enable"]
632    #[inline]
633    pub fn txeie(&self) -> TXEIER {
634        let bits = {
635            const MASK: bool = true;
636            const OFFSET: u8 = 7;
637            ((self.bits >> OFFSET) & MASK as u32) != 0
638        };
639        TXEIER { bits }
640    }
641    #[doc = "Bits 8:11 - Data size"]
642    #[inline]
643    pub fn ds(&self) -> DSR {
644        let bits = {
645            const MASK: u8 = 15;
646            const OFFSET: u8 = 8;
647            ((self.bits >> OFFSET) & MASK as u32) as u8
648        };
649        DSR { bits }
650    }
651    #[doc = "Bit 12 - FIFO reception threshold"]
652    #[inline]
653    pub fn frxth(&self) -> FRXTHR {
654        let bits = {
655            const MASK: bool = true;
656            const OFFSET: u8 = 12;
657            ((self.bits >> OFFSET) & MASK as u32) != 0
658        };
659        FRXTHR { bits }
660    }
661    #[doc = "Bit 13 - Last DMA transfer for reception"]
662    #[inline]
663    pub fn ldma_rx(&self) -> LDMA_RXR {
664        let bits = {
665            const MASK: bool = true;
666            const OFFSET: u8 = 13;
667            ((self.bits >> OFFSET) & MASK as u32) != 0
668        };
669        LDMA_RXR { bits }
670    }
671    #[doc = "Bit 14 - Last DMA transfer for transmission"]
672    #[inline]
673    pub fn ldma_tx(&self) -> LDMA_TXR {
674        let bits = {
675            const MASK: bool = true;
676            const OFFSET: u8 = 14;
677            ((self.bits >> OFFSET) & MASK as u32) != 0
678        };
679        LDMA_TXR { bits }
680    }
681}
682impl W {
683    #[doc = r" Reset value of the register"]
684    #[inline]
685    pub fn reset_value() -> W {
686        W { bits: 0 }
687    }
688    #[doc = r" Writes raw bits to the register"]
689    #[inline]
690    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
691        self.bits = bits;
692        self
693    }
694    #[doc = "Bit 0 - Rx buffer DMA enable"]
695    #[inline]
696    pub fn rxdmaen(&mut self) -> _RXDMAENW {
697        _RXDMAENW { w: self }
698    }
699    #[doc = "Bit 1 - Tx buffer DMA enable"]
700    #[inline]
701    pub fn txdmaen(&mut self) -> _TXDMAENW {
702        _TXDMAENW { w: self }
703    }
704    #[doc = "Bit 2 - SS output enable"]
705    #[inline]
706    pub fn ssoe(&mut self) -> _SSOEW {
707        _SSOEW { w: self }
708    }
709    #[doc = "Bit 3 - NSS pulse management"]
710    #[inline]
711    pub fn nssp(&mut self) -> _NSSPW {
712        _NSSPW { w: self }
713    }
714    #[doc = "Bit 4 - Frame format"]
715    #[inline]
716    pub fn frf(&mut self) -> _FRFW {
717        _FRFW { w: self }
718    }
719    #[doc = "Bit 5 - Error interrupt enable"]
720    #[inline]
721    pub fn errie(&mut self) -> _ERRIEW {
722        _ERRIEW { w: self }
723    }
724    #[doc = "Bit 6 - RX buffer not empty interrupt enable"]
725    #[inline]
726    pub fn rxneie(&mut self) -> _RXNEIEW {
727        _RXNEIEW { w: self }
728    }
729    #[doc = "Bit 7 - Tx buffer empty interrupt enable"]
730    #[inline]
731    pub fn txeie(&mut self) -> _TXEIEW {
732        _TXEIEW { w: self }
733    }
734    #[doc = "Bits 8:11 - Data size"]
735    #[inline]
736    pub fn ds(&mut self) -> _DSW {
737        _DSW { w: self }
738    }
739    #[doc = "Bit 12 - FIFO reception threshold"]
740    #[inline]
741    pub fn frxth(&mut self) -> _FRXTHW {
742        _FRXTHW { w: self }
743    }
744    #[doc = "Bit 13 - Last DMA transfer for reception"]
745    #[inline]
746    pub fn ldma_rx(&mut self) -> _LDMA_RXW {
747        _LDMA_RXW { w: self }
748    }
749    #[doc = "Bit 14 - Last DMA transfer for transmission"]
750    #[inline]
751    pub fn ldma_tx(&mut self) -> _LDMA_TXW {
752        _LDMA_TXW { w: self }
753    }
754}
stm32l4x2_pac/spi1/cr2.rs

stm32l4x2_pac/spi1/
cr2.rs
