SFBSDRaw.h

Go to the documentation of this file.

/*                                             -*- mode:C++; fill-column:100 -*-
  SFBSDRaw.h - Bit-banged SDCard raw disk access.
  Copyright (C) 2010 The Regents of the University of New Mexico
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
  USA

  $Id$
 */

#ifndef SFBSDRAW_H
#define SFBSDRAW_H

#include "SFBTypes.h"           // For u32 etc
#include "SFBConstants.h"       // For FACE_COUNT

#define SDRAW_BLOCK_SIZE_BIT_COUNT 9
#define SDRAW_BLOCK_SIZE (1<<(SDRAW_BLOCK_SIZE_BIT_COUNT)) // 512 bytes per block
#define SDRAW_BLOCK_SIZE_BIT_MASK ((SDRAW_BLOCK_SIZE)-1)

struct SDRawDiskInfo {
  u32 serialNumber;             
  u32 blockCount;               
  u8 manufacturer;              
  u8 oem[2+1];                  
  u8 product[5+1];              
  u8 revision;                  
  u8 year;                      
  u8 month;                     
  u8 format;                    
  bool copy;                    
  bool writeProtect;            
  bool writeProtectTemporary;   
};

class SDRaw {
public:
  enum State { 
    NOT_BEGUN=0,                
    UNINITTED,                  
    RESET_FAILED,               
    CRC_ON_FAILED,              
    TYPE_CHECK_FAILED,          
    OP_COND_FAILED,             
    READ_OCR_FAILED,            
    CONFIG_FAILED,              
    ACTIVE,                     
    INACTIVE_READ,              
    INACTIVE_WRITE,             
    ERROR_READ_SINGLE_BLOCK,    
    ERROR_READ_REGISTER,        
    ERROR_READ_TIMEOUT_DATA,    
    ERROR_READ_CRC_DATA,        
    ERROR_BAD_CSD_VERSION,      
    ERROR_WRITE_TIMEOUT_DATA,   
    ERROR_WRITE_SINGLE_BLOCK    
  };

  void begin(u8 face) ;

  void begin(u8 face, u8 CSPin, u8 clkPin, u8 MOSIpin, u8 MISOpin) ;

  bool end() ;

  u32 getState() { return status; }

  u32 getBlockCount() { return isActive() ? blockCapacity : 0; }

  u64 getByteCount() { return ((u64) getBlockCount())<<SDRAW_BLOCK_SIZE_BIT_COUNT; }

  u8 getFace() { return sdFace; }

  bool init() ;

  bool isActive() { return getState()==ACTIVE; }

  bool getInfo(SDRawDiskInfo & info) ;

  bool setBlockBuffer(u8 * buffer, u32 bufferLength) ;

  bool read(u64 address, u8* data, u32 length) ;

  bool readBlock(u32 blockNumber, u8* buffer, u32 blockOffset = 0, u32 length = 512) ;
  
  bool write(u64 address, const u8* data, u32 length) ;

  bool writeBlock(u32 blockNumber, const u8* buffer) ;

  bool sync() ;

  bool isSDHC() { return (flags&HC_CARD); }

  void setSpiLog(bool val) { if (val) flags |= SPI_LOG; else flags &= ~SPI_LOG; }

  u32 readStatus() ;

private:
  enum { SHORT_TRIES = 50, LONG_TRIES = 50000 };

  enum {
    BLOCK_DIRTY = 0x01,
    HC_CARD     = 0x02,
    SPI_LOG     = 0x04,
    FLAG_RSRV3  = 0x08,
    FLAG_RSRV4  = 0x10,
    FLAG_RSRV5  = 0x20,
    FLAG_RSRV6  = 0x40,
    FLAG_RSRV7  = 0x80
  };
  u32 blockCapacity;            // Number of blocks that fit on the disk
  u32 cachedBlockNumber;        // Number of currently buffered block
  u8 * cachedBlock;             // Zero for no buffering or ptr to 512 bytes
  u8 flags;                     // Dirty bit
  u8 status;                    // Operational status
  u8 sdFace;                    // Face to power cycle to init card
  u8 sdCSel;                    // Pin for chip select
  u8 sdClk;                     // Pin for clock
  u8 sdMOSI;                    // Pin for master-out-slave-in
  u8 sdMISO;                    // Pin for master-in-slave-out

  void startTransaction() ;
  void endTransaction() ;

  bool dieWith(u32 newStatus) ;

  bool readRegister(u32 cmd, u8 reg[16]);

  void sendBitsSlow(u32 data, u32 bitCount) ;  // Used during init only
  u32 recvBitsSlow(u32 bitCount) ;             // Used during init only

  void sendBits(u32 bits, u32 bitCount) ;
  u32 recvBits(u32 bitCount) ;

  void sendByte(u8 data) { sendBits(data,8); }
  u8 recvByte() { return (u8) recvBits(8); }

  u8 sendCmd(u8 cmd, u32 arg) ;

  bool loadCache(u32 blockNumber) ;
  bool writeBuffered(u64 offset, const u8* buffer, u32 length) ;
  bool readBuffered(u64 offset, u8* buffer, u32 length) ;

};

#endif /* SFBSDRAW_H */