inky_frame/
sd.rs

1// Permission is hereby granted, free of charge, to any person obtaining a copy
2// of this software and associated documentation files (the "Software"), to deal
3// in the Software without restriction, including without limitation the rights
4// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
5// copies of the Software, and to permit persons to whom the Software is
6// furnished to do so, subject to the following conditions:
7//
8// The above copyright notice and this permission notice shall be included in
9// all copies or substantial portions of the Software.
10//
11// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
12// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
14// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
15// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
16// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
17// SOFTWARE.
18//
19
20#![no_implicit_prelude]
21
22extern crate core;
23extern crate rpsp;
24
25use core::clone::Clone;
26use core::convert::{From, Into};
27use core::fmt::{self, Debug, Formatter};
28use core::matches;
29use core::ops::{Deref, DerefMut};
30use core::ptr::NonNull;
31use core::result::Result::{self, Err, Ok};
32
33use rpsp::Pico;
34use rpsp::clock::Timer;
35use rpsp::pin::gpio::Output;
36use rpsp::pin::{Pin, PinID};
37use rpsp::spi::{Spi, SpiBus, SpiIO};
38
39use crate::fs::{Block, BlockDevice, DeviceError};
40
41const CMD0: u8 = 0x00u8;
42const CMD8: u8 = 0x08u8;
43const CMD9: u8 = 0x09u8;
44const CMD12: u8 = 0x0Cu8;
45const CMD13: u8 = 0x0Du8;
46const CMD17: u8 = 0x11u8;
47const CMD18: u8 = 0x12u8;
48const CMD24: u8 = 0x18u8;
49const CMD25: u8 = 0x19u8;
50const CMD55: u8 = 0x37u8;
51const CMD58: u8 = 0x3Au8;
52const CMD59: u8 = 0x3Bu8;
53const CMDA23: u8 = 0x17u8;
54const CMDA41: u8 = 0x29u8;
55
56pub enum CardType {
57    None,
58    SD1,
59    SD2,
60    SDHC,
61}
62#[repr(u8)]
63pub enum CardError {
64    Timeout         = 0x0,
65    ReadError       = 0x1,
66    WriteError      = 0x2,
67    InitFailed      = 0xA,
68    InvalidDevice   = 0xB,
69    InvalidOptions  = 0xC,
70    InvalidResponse = 0xD,
71    InvalidChecksum = 0xE,
72}
73
74pub struct CardInfo {
75    v2:  bool,
76    buf: [u8; 16],
77}
78pub struct Card<'a> {
79    cs:       Pin<Output>,
80    spi:      SpiBus<'a>,
81    timer:    Timer,
82    ver:      CardType,
83    crc:      bool,
84    attempts: u16,
85}
86
87struct Counter {
88    t:   NonNull<Timer>,
89    cur: u16,
90    hit: u16,
91}
92
93impl Counter {
94    #[inline(always)]
95    fn reset(&mut self) {
96        self.cur = 0;
97    }
98    #[inline]
99    fn wait(&mut self) -> Result<(), CardError> {
100        if self.cur >= self.hit {
101            return Err(CardError::Timeout);
102        }
103        unsafe { (&*self.t.as_ptr()).sleep_us(10) };
104        self.cur += 1;
105        Ok(())
106    }
107}
108impl Card<'_> {
109    #[inline(always)]
110    pub fn new<'a>(p: &Pico, cs: PinID, spi: impl Into<SpiBus<'a>>) -> Card<'a> {
111        Card::new_crc(p, cs, spi, true)
112    }
113    #[inline]
114    pub fn new_crc<'a>(p: &Pico, cs: PinID, spi: impl Into<SpiBus<'a>>, crc: bool) -> Card<'a> {
115        Card {
116            crc,
117            cs: p.pin(cs).output_high(),
118            spi: spi.into(),
119            ver: CardType::None,
120            timer: p.timer().clone(),
121            attempts: 0xFFFu16,
122        }
123    }
124
125    #[inline(always)]
126    pub fn bus(&self) -> &Spi {
127        &self.spi
128    }
129    #[inline(always)]
130    pub fn blocks(&mut self) -> Result<u32, CardError> {
131        Ok(self.info()?.blocks())
132    }
133    pub fn info(&mut self) -> Result<CardInfo, CardError> {
134        if matches!(self.ver, CardType::None) {
135            self.init()?;
136        }
137        let mut i = match self.ver {
138            CardType::None => return Err(CardError::InitFailed),
139            CardType::SD2 | CardType::SDHC => CardInfo::new(true),
140            CardType::SD1 => CardInfo::new(false),
141        };
142        self.cs.low();
143        let r = match self.cmd(CMD9, 0) {
144            Ok(v) if v == 0 => self.read(&mut i.buf),
145            Ok(_) => Err(CardError::InvalidResponse),
146            Err(e) => Err(e),
147        };
148        self.cs.high();
149        r.map(|_| i)
150    }
151    #[inline]
152    pub fn write_block(&mut self, b: &Block, start: u32) -> Result<(), CardError> {
153        if matches!(self.ver, CardType::None) {
154            self.init()?;
155        }
156        self.cs.low();
157        let r = self._write_block(b, self.index(start)?);
158        self.cs.high();
159        r
160    }
161    #[inline]
162    pub fn read_block(&mut self, b: &mut Block, start: u32) -> Result<(), CardError> {
163        if matches!(self.ver, CardType::None) {
164            self.init()?;
165        }
166        self.cs.low();
167        let r = self._read_block(b, self.index(start)?);
168        self.cs.high();
169        r
170    }
171    #[inline]
172    pub fn write_blocks(&mut self, b: &[Block], start: u32) -> Result<(), CardError> {
173        if matches!(self.ver, CardType::None) {
174            self.init()?;
175        }
176        self.cs.low();
177        let r = self._write_blocks(b, self.index(start)?);
178        self.cs.high();
179        r
180    }
181    #[inline]
182    pub fn read_blocks(&mut self, b: &mut [Block], start: u32) -> Result<(), CardError> {
183        if matches!(self.ver, CardType::None) {
184            self.init()?;
185        }
186        self.cs.low();
187        let r = self._read_blocks(b, self.index(start)?);
188        self.cs.high();
189        r
190    }
191
192    #[inline(always)]
193    fn read_byte(&mut self) -> u8 {
194        self.spi.transfer_single(0xFFu8)
195    }
196    #[inline(always)]
197    fn counter(&mut self) -> Counter {
198        Counter {
199            t:   unsafe { NonNull::new_unchecked(&mut self.timer) },
200            cur: 0,
201            hit: self.attempts,
202        }
203    }
204    #[inline]
205    fn init(&mut self) -> Result<(), CardError> {
206        self.cs.low();
207        let r = self._init();
208        self.cs.high();
209        r
210    }
211    fn _init(&mut self) -> Result<(), CardError> {
212        // TODO(sf): Fix the issue with some non-Sandisk cards not working and
213        //           freezing here.
214        let mut c = self.counter();
215        loop {
216            match self.cmd(CMD0, 0) {
217                Err(CardError::Timeout) => {
218                    for _ in 0..0xFF {
219                        self.spi.write_single(0xFFu8);
220                    }
221                },
222                Err(e) => return Err(e),
223                Ok(0x1) => break,
224                Ok(_) => continue,
225            }
226            c.wait()?;
227        }
228        if self.crc && self.cmd(CMD59, 0x1)? != 0x1 {
229            return Err(CardError::InvalidOptions);
230        }
231        c.reset();
232        let a = loop {
233            if self.cmd(CMD8, 0x1AA)? == 0x5 {
234                self.ver = CardType::SD1;
235                break 0;
236            }
237            let mut b = [0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8];
238            self.spi.transfer_in_place(&mut b);
239            if b[3] == 0xAA {
240                self.ver = CardType::SD2;
241                break 0x40000000;
242            }
243            c.wait()?;
244        };
245        c.reset();
246        while self.cmd_app(CMDA41, a)? != 0 {
247            c.wait()?;
248        }
249        if !matches!(self.ver, CardType::SD2) {
250            return Ok(());
251        }
252        if self.cmd(CMD58, 0)? != 0 {
253            return Err(CardError::InvalidResponse);
254        }
255        let mut b = [0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8];
256        self.spi.transfer_in_place(&mut b);
257        if (b[0] & 0xC0) == 0xC0 {
258            self.ver = CardType::SDHC;
259        }
260        let _ = self.read_byte();
261        Ok(())
262    }
263    #[inline]
264    fn wait_busy(&mut self) -> Result<(), CardError> {
265        let mut c = self.counter();
266        loop {
267            if self.read_byte() == 0xFF {
268                return Ok(());
269            }
270            c.wait()?;
271        }
272    }
273    #[inline(always)]
274    fn index(&self, s: u32) -> Result<u32, CardError> {
275        match self.ver {
276            CardType::None => Err(CardError::InitFailed),
277            CardType::SDHC => Ok(s),
278            CardType::SD1 | CardType::SD2 => Ok(s * 0x200),
279        }
280    }
281    fn read(&mut self, b: &mut [u8]) -> Result<(), CardError> {
282        let mut c = self.counter();
283        loop {
284            match self.read_byte() {
285                0xFF => (),
286                0xFE => break,
287                _ => return Err(CardError::ReadError),
288            }
289            c.wait()?;
290        }
291        self.spi.read_with(0xFFu8, b);
292        let mut v = [0xFFu8, 0xFFu8];
293        self.spi.transfer_in_place(&mut v);
294        if !self.crc {
295            return Ok(());
296        }
297        let c = u16::from_be_bytes(v);
298        let a = crc_v16(b);
299        if a != c { Err(CardError::InvalidChecksum) } else { Ok(()) }
300    }
301    fn cmd(&mut self, x: u8, arg: u32) -> Result<u8, CardError> {
302        if x != CMD0 && x != CMD12 {
303            self.wait_busy()?;
304        }
305        let mut b = [
306            0x40u8 | x,
307            (arg >> 24) as u8,
308            (arg >> 16) as u8,
309            (arg >> 8) as u8,
310            arg as u8,
311            0,
312        ];
313        b[5] = crc_v7(&b[0..5]);
314        self.spi.write(&b);
315        if x == CMD12 {
316            let _ = self.read_byte();
317        }
318        let mut c = self.counter();
319        loop {
320            let v = self.read_byte();
321            if (v & 0x80) == 0 {
322                return Ok(v);
323            }
324            c.wait()?;
325        }
326    }
327    fn write(&mut self, t: u8, b: &[u8]) -> Result<(), CardError> {
328        self.spi.write_single(t);
329        self.spi.write(b);
330        let c = if self.crc { crc_v16(b).to_be_bytes() } else { [0xFFu8, 0xFFu8] };
331        self.spi.write(&c);
332        if self.read_byte() & 0x1F != 0x5 { Err(CardError::WriteError) } else { Ok(()) }
333    }
334    #[inline(always)]
335    fn cmd_app(&mut self, x: u8, arg: u32) -> Result<u8, CardError> {
336        self.cmd(CMD55, 0)?;
337        self.cmd(x, arg)
338    }
339    fn _write_block(&mut self, b: &Block, i: u32) -> Result<(), CardError> {
340        self.cmd(CMD24, i)?;
341        self.write(0xFE, &b)?;
342        self.wait_busy()?;
343        if self.cmd(CMD13, 0)? != 0 {
344            return Err(CardError::WriteError);
345        }
346        if self.read_byte() != 0 {
347            return Err(CardError::WriteError);
348        }
349        Ok(())
350    }
351    #[inline(always)]
352    fn _read_block(&mut self, b: &mut Block, i: u32) -> Result<(), CardError> {
353        self.cmd(CMD17, i)?;
354        self.read(b)
355    }
356    fn _write_blocks(&mut self, b: &[Block], i: u32) -> Result<(), CardError> {
357        if b.len() == 1 {
358            return self._write_block(&b[0], i);
359        }
360        self.cmd_app(CMDA23, b.len() as u32)?;
361        self.wait_busy()?;
362        self.cmd(CMD25, i)?;
363        for v in b.iter() {
364            self.wait_busy()?;
365            self.write(0xFC, v)?;
366        }
367        self.wait_busy()?;
368        self.spi.write_single(0xFDu8);
369        Ok(())
370    }
371    fn _read_blocks(&mut self, b: &mut [Block], i: u32) -> Result<(), CardError> {
372        if b.len() == 1 {
373            return self._read_block(&mut b[0], i);
374        }
375        self.cmd(CMD18, i)?;
376        for v in b.iter_mut() {
377            self.read(v)?;
378        }
379        self.cmd(CMD12, 0)?;
380        Ok(())
381    }
382}
383impl CardInfo {
384    #[inline(always)]
385    fn new(v2: bool) -> CardInfo {
386        CardInfo { v2, buf: [0u8; 16] }
387    }
388
389    #[inline(always)]
390    pub fn crc(&self) -> u8 {
391        self.buf[0xF] & 0xFF
392    }
393    #[inline]
394    pub fn size(&self) -> u64 {
395        if self.v2 {
396            (self.device_size() as u64 + 1) * 0x200 * 0x400
397        } else {
398            (self.device_size() as u64 + 1) << (self.device_size_multiplier() as u64 * self.block_length() as u64 + 2)
399        }
400    }
401    #[inline]
402    pub fn blocks(&self) -> u32 {
403        if self.v2 {
404            (self.device_size() + 1) * 0x400
405        } else {
406            (self.device_size() + 1) << (self.device_size_multiplier() as u32 * self.block_length() as u32 + 7)
407        }
408    }
409    #[inline(always)]
410    pub fn is_v2(&self) -> bool {
411        self.v2
412    }
413    #[inline(always)]
414    pub fn block_length(&self) -> u8 {
415        self.buf[0x5] & 0xF
416    }
417    #[inline(always)]
418    pub fn device_size(&self) -> u32 {
419        if self.v2 {
420            (((self.buf[0x7] & 0x3F) as u32) << 8) | (((self.buf[0x8] & 0xFF) as u32) << 8) | ((self.buf[0x9] & 0xFF) as u32)
421        } else {
422            (((self.buf[0x6] & 0x3) as u32) << 8) | (((self.buf[0x7] & 0xFF) as u32) << 8) | (((self.buf[0x8] >> 0x6) & 0x3) as u32)
423        }
424    }
425    #[inline(always)]
426    pub fn device_size_multiplier(&self) -> u8 {
427        if self.v2 { ((self.buf[0x9] & 0x3) << 1) | (self.buf[0xA] >> 0x7) } else { 0u8 }
428    }
429}
430
431impl Deref for CardInfo {
432    type Target = [u8];
433
434    #[inline(always)]
435    fn deref(&self) -> &[u8] {
436        &self.buf
437    }
438}
439impl DerefMut for CardInfo {
440    #[inline(always)]
441    fn deref_mut(&mut self) -> &mut [u8] {
442        &mut self.buf
443    }
444}
445
446impl BlockDevice for Card<'_> {
447    #[inline(always)]
448    fn blocks(&mut self) -> Result<u32, DeviceError> {
449        Ok(self.blocks()?)
450    }
451    #[inline(always)]
452    fn write(&mut self, b: &[Block], start: u32) -> Result<(), DeviceError> {
453        Ok(self.write_blocks(b, start)?)
454    }
455    #[inline(always)]
456    fn read(&mut self, b: &mut [Block], start: u32) -> Result<(), DeviceError> {
457        Ok(self.read_blocks(b, start)?)
458    }
459    #[inline(always)]
460    fn write_single(&mut self, b: &Block, start: u32) -> Result<(), DeviceError> {
461        Ok(self.write_block(b, start)?)
462    }
463    #[inline(always)]
464    fn read_single(&mut self, b: &mut Block, start: u32) -> Result<(), DeviceError> {
465        Ok(self.read_block(b, start)?)
466    }
467}
468
469impl From<CardError> for DeviceError {
470    #[inline(always)]
471    fn from(v: CardError) -> DeviceError {
472        match v {
473            CardError::Timeout => DeviceError::Timeout,
474            CardError::ReadError => DeviceError::ReadError,
475            CardError::WriteError => DeviceError::WriteError,
476            CardError::InvalidChecksum => DeviceError::BadData,
477            CardError::InvalidOptions => DeviceError::InvalidOptions,
478            _ => DeviceError::Hardware(v as u8),
479        }
480    }
481}
482
483#[cfg(feature = "debug")]
484impl Debug for CardError {
485    #[inline]
486    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
487        match self {
488            CardError::Timeout => f.write_str("Timeout"),
489            CardError::ReadError => f.write_str("ReadError"),
490            CardError::WriteError => f.write_str("WriteError"),
491            CardError::InitFailed => f.write_str("InitFailed"),
492            CardError::InvalidDevice => f.write_str("InvalidDevice"),
493            CardError::InvalidOptions => f.write_str("InvalidOptions"),
494            CardError::InvalidResponse => f.write_str("InvalidResponse"),
495            CardError::InvalidChecksum => f.write_str("InvalidChecksum"),
496        }
497    }
498}
499#[cfg(not(feature = "debug"))]
500impl Debug for CardError {
501    #[inline(always)]
502    fn fmt(&self, _f: &mut Formatter<'_>) -> fmt::Result {
503        Ok(())
504    }
505}
506
507fn crc_v7(b: &[u8]) -> u8 {
508    let mut r = 0u8;
509    for i in b {
510        let mut v = *i;
511        for _ in 0..8 {
512            r <<= 1;
513            if ((v & 0x80) ^ (r & 0x80)) != 0 {
514                r ^= 0x9;
515            }
516            v <<= 1;
517        }
518    }
519    (r << 1) | 1
520}
521fn crc_v16(b: &[u8]) -> u16 {
522    let mut r = 0u16;
523    for i in b {
524        r = ((r >> 8) & 0xFF) | (r << 8);
525        r ^= *i as u16;
526        r ^= (r & 0xFF) >> 4;
527        r ^= r << 12;
528        r ^= (r & 0xFF) << 5;
529    }
530    r
531}
inky_frame/sd.rs

inky_frame/
sd.rs
