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

#![no_std]

use embedded_hal::serial::{Read, Write};
use evegfx::interface::Interface;
use spidriver::SPIDriver;

pub struct EVESPIDriverInterface<TX, RX>
where
    TX: Write<u8>,
    RX: Read<u8>,
{
    sd: SPIDriver<TX, RX>,
}

impl<TX, RX> EVESPIDriverInterface<TX, RX>
where
    TX: Write<u8>,
    RX: Read<u8>,
{
    pub fn new(sd: SPIDriver<TX, RX>) -> Self {
        Self { sd: sd }
    }
}

impl<TX, RX> Interface for EVESPIDriverInterface<TX, RX>
where
    TX: Write<u8>,
    RX: Read<u8>,
{
    type Error = spidriver::Error<TX::Error, RX::Error>;

    fn reset(&mut self) -> Result<(), Self::Error> {
        // Just make sure we we're not already asserting CS.
        self.sd.unselect()
    }

    fn begin_write(&mut self, addr: u32) -> Result<(), Self::Error> {
        self.sd.select()?;
        let mut addr_words: [u8; 3] = [0; 3];
        self.build_write_header(addr, &mut addr_words);
        self.sd.write(&addr_words)
    }

    fn continue_write(&mut self, v: &[u8]) -> Result<(), Self::Error> {
        self.sd.write(v)
    }

    fn end_write(&mut self) -> Result<(), Self::Error> {
        self.sd.unselect()
    }

    fn begin_read(&mut self, addr: u32) -> Result<(), Self::Error> {
        self.sd.select()?;
        let mut addr_words: [u8; 4] = [0; 4];
        self.build_read_header(addr, &mut addr_words);
        self.sd.write(&addr_words)
    }

    fn continue_read(&mut self, into: &mut [u8]) -> Result<(), Self::Error> {
        // The underlying SPIDriver API can only read 64 bytes at a time,
        // so if our buffer is larger than that then we'll need to make
        // multiple calls.
        const MAX_SIZE: usize = 64;

        let mut remain = into;
        while remain.len() > 0 {
            let remain_size = remain.len();
            let size = if remain_size > MAX_SIZE {
                MAX_SIZE
            } else {
                remain_size
            };
            {
                let this = &mut remain[..size];
                self.sd.transfer(this)?;
            }
            remain = &mut remain[size..];
        }
        Ok(())
    }

    fn end_read(&mut self) -> Result<(), Self::Error> {
        self.sd.unselect()
    }

    fn host_cmd(&mut self, cmd: u8, a0: u8, a1: u8) -> Result<(), Self::Error> {
        let mut cmd_words: [u8; 3] = [0; 3];
        self.build_host_cmd_msg(cmd, a0, a1, &mut cmd_words);
        self.sd.select()?;
        self.sd.write(&cmd_words)?;
        self.sd.unselect()
    }
}