Quadrotor

/* Arduino SdFat Library

 * Copyright (C) 2009 by William Greiman

 *

 * This file is part of the Arduino SdFat Library

 *

 * This Library is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with the Arduino SdFat Library.  If not, see

 * <http://www.gnu.org/licenses/>.

 */

#include <SdFat.h>

//------------------------------------------------------------------------------

// raw block cache

// init cacheBlockNumber_to invalid SD block number

uint32_t SdVolume::cacheBlockNumber_ = 0XFFFFFFFF;

cache_t  SdVolume::cacheBuffer_;     // 512 byte cache for Sd2Card

Sd2Card* SdVolume::sdCard_;          // pointer to SD card object

uint8_t  SdVolume::cacheDirty_ = 0;  // cacheFlush() will write block if true

uint32_t SdVolume::cacheMirrorBlock_ = 0;  // mirror  block for second FAT

//------------------------------------------------------------------------------

// find a contiguous group of clusters

uint8_t SdVolume::allocContiguous(uint32_t count, uint32_t* curCluster) {

  // start of group

  uint32_t bgnCluster;

  // flag to save place to start next search

  uint8_t setStart;

  // set search start cluster

  if (*curCluster) {

    // try to make file contiguous

    bgnCluster = *curCluster + 1;

    // don't save new start location

    setStart = false;

  } else {

    // start at likely place for free cluster

    bgnCluster = allocSearchStart_;

    // save next search start if one cluster

    setStart = 1 == count;

  }

  // end of group

  uint32_t endCluster = bgnCluster;

  // last cluster of FAT

  uint32_t fatEnd = clusterCount_ + 1;

  // search the FAT for free clusters

  for (uint32_t n = 0;; n++, endCluster++) {

    // can't find space checked all clusters

    if (n >= clusterCount_) return false;

    // past end - start from beginning of FAT

    if (endCluster > fatEnd) {

      bgnCluster = endCluster = 2;

    }

    uint32_t f;

    if (!fatGet(endCluster, &f)) return false;

    if (f != 0) {

      // cluster in use try next cluster as bgnCluster

      bgnCluster = endCluster + 1;

    } else if ((endCluster - bgnCluster + 1) == count) {

      // done - found space

      break;

    }

  }

  // mark end of chain

  if (!fatPutEOC(endCluster)) return false;

  // link clusters

  while (endCluster > bgnCluster) {

    if (!fatPut(endCluster - 1, endCluster)) return false;

    endCluster--;

  }

  if (*curCluster != 0) {

    // connect chains

    if (!fatPut(*curCluster, bgnCluster)) return false;

  }

  // return first cluster number to caller

  *curCluster = bgnCluster;

  // remember possible next free cluster

  if (setStart) allocSearchStart_ = bgnCluster + 1;

  return true;

}

//------------------------------------------------------------------------------

uint8_t SdVolume::cacheFlush(void) {

  if (cacheDirty_) {

    if (!sdCard_->writeBlock(cacheBlockNumber_, cacheBuffer_.data)) {

      return false;

    }

    // mirror FAT tables

    if (cacheMirrorBlock_) {

      if (!sdCard_->writeBlock(cacheMirrorBlock_, cacheBuffer_.data)) {

        return false;

      }

      cacheMirrorBlock_ = 0;

    }

    cacheDirty_ = 0;

  }

  return true;

}

//------------------------------------------------------------------------------

uint8_t SdVolume::cacheRawBlock(uint32_t blockNumber, uint8_t action) {

  if (cacheBlockNumber_ != blockNumber) {

    if (!cacheFlush()) return false;

    if (!sdCard_->readBlock(blockNumber, cacheBuffer_.data)) return false;

    cacheBlockNumber_ = blockNumber;

  }

  cacheDirty_ |= action;

  return true;

}

//------------------------------------------------------------------------------

// cache a zero block for blockNumber

uint8_t SdVolume::cacheZeroBlock(uint32_t blockNumber) {

  if (!cacheFlush()) return false;

  // loop take less flash than memset(cacheBuffer_.data, 0, 512);

  for (uint16_t i = 0; i < 512; i++) {

    cacheBuffer_.data[i] = 0;

  }

  cacheBlockNumber_ = blockNumber;

  cacheSetDirty();

  return true;

}

//------------------------------------------------------------------------------

// return the size in bytes of a cluster chain

uint8_t SdVolume::chainSize(uint32_t cluster, uint32_t* size) const {

  uint32_t s = 0;

  do {

    if (!fatGet(cluster, &cluster)) return false;

    s += 512UL << clusterSizeShift_;

  } while (!isEOC(cluster));

  *size = s;

  return true;

}

//------------------------------------------------------------------------------

// Fetch a FAT entry

uint8_t SdVolume::fatGet(uint32_t cluster, uint32_t* value) const {

  if (cluster > (clusterCount_ + 1)) return false;

  uint32_t lba = fatStartBlock_;

  lba += fatType_ == 16 ? cluster >> 8 : cluster >> 7;

  if (lba != cacheBlockNumber_) {

    if (!cacheRawBlock(lba, CACHE_FOR_READ)) return false;

  }

  if (fatType_ == 16) {

    *value = cacheBuffer_.fat16[cluster & 0XFF];

  } else {

    *value = cacheBuffer_.fat32[cluster & 0X7F] & FAT32MASK;

  }

  return true;

}

//------------------------------------------------------------------------------

// Store a FAT entry

uint8_t SdVolume::fatPut(uint32_t cluster, uint32_t value) {

  // error if reserved cluster

  if (cluster < 2) return false;

  // error if not in FAT

  if (cluster > (clusterCount_ + 1)) return false;

  // calculate block address for entry

  uint32_t lba = fatStartBlock_;

  lba += fatType_ == 16 ? cluster >> 8 : cluster >> 7;

  if (lba != cacheBlockNumber_) {

    if (!cacheRawBlock(lba, CACHE_FOR_READ)) return false;

  }

  // store entry

  if (fatType_ == 16) {

    cacheBuffer_.fat16[cluster & 0XFF] = value;

  } else {

    cacheBuffer_.fat32[cluster & 0X7F] = value;

  }

  cacheSetDirty();

  // mirror second FAT

  if (fatCount_ > 1) cacheMirrorBlock_ = lba + blocksPerFat_;

  return true;

}

//------------------------------------------------------------------------------

// free a cluster chain

uint8_t SdVolume::freeChain(uint32_t cluster) {

  // clear free cluster location

  allocSearchStart_ = 2;

  do {

    uint32_t next;

    if (!fatGet(cluster, &next)) return false;

    // free cluster

    if (!fatPut(cluster, 0)) return false;

    cluster = next;

  } while (!isEOC(cluster));

  return true;

}

//------------------------------------------------------------------------------

/**

 * Initialize a FAT volume.

 *

 * \param[in] dev The SD card where the volume is located.

 *

 * \param[in] part The partition to be used.  Legal values for \a part are

 * 1-4 to use the corresponding partition on a device formatted with

 * a MBR, Master Boot Record, or zero if the device is formatted as

 * a super floppy with the FAT boot sector in block zero.

 *

 * \return The value one, true, is returned for success and

 * the value zero, false, is returned for failure.  Reasons for

 * failure include not finding a valid partition, not finding a valid

 * FAT file system in the specified partition or an I/O error.

 */

uint8_t SdVolume::init(Sd2Card* dev, uint8_t part) {

  uint32_t volumeStartBlock = 0;

  sdCard_ = dev;

  // if part == 0 assume super floppy with FAT boot sector in block zero

  // if part > 0 assume mbr volume with partition table

  if (part) {

    if (part > 4)return false;

    if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) return false;

    part_t* p = &cacheBuffer_.mbr.part[part-1];

    if ((p->boot & 0X7F) !=0  ||

      p->totalSectors < 100 ||

      p->firstSector == 0) {

      // not a valid partition

      return false;

    }

    volumeStartBlock = p->firstSector;

  }

  if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) return false;

  bpb_t* bpb = &cacheBuffer_.fbs.bpb;

  if (bpb->bytesPerSector != 512 ||

    bpb->fatCount == 0 ||

    bpb->reservedSectorCount == 0 ||

    bpb->sectorsPerCluster == 0) {

       // not valid FAT volume

      return false;

  }

  fatCount_ = bpb->fatCount;

  blocksPerCluster_ = bpb->sectorsPerCluster;

  // determine shift that is same as multiply by blocksPerCluster_

  clusterSizeShift_ = 0;

  while (blocksPerCluster_ != (1 << clusterSizeShift_)) {

    // error if not power of 2

    if (clusterSizeShift_++ > 7) return false;

  }

  blocksPerFat_ = bpb->sectorsPerFat16 ?

                    bpb->sectorsPerFat16 : bpb->sectorsPerFat32;

  fatStartBlock_ = volumeStartBlock + bpb->reservedSectorCount;

  // count for FAT16 zero for FAT32

  rootDirEntryCount_ = bpb->rootDirEntryCount;

  // directory start for FAT16 dataStart for FAT32

  rootDirStart_ = fatStartBlock_ + bpb->fatCount * blocksPerFat_;

  // data start for FAT16 and FAT32

  dataStartBlock_ = rootDirStart_ + ((32 * bpb->rootDirEntryCount + 511)/512);

  // total blocks for FAT16 or FAT32

  uint32_t totalBlocks = bpb->totalSectors16 ?

                           bpb->totalSectors16 : bpb->totalSectors32;

  // total data blocks

  clusterCount_ = totalBlocks - (dataStartBlock_ - volumeStartBlock);

  // divide by cluster size to get cluster count

  clusterCount_ >>= clusterSizeShift_;

  // FAT type is determined by cluster count

  if (clusterCount_ < 4085) {

    fatType_ = 12;

  } else if (clusterCount_ < 65525) {

    fatType_ = 16;

  } else {

    rootDirStart_ = bpb->fat32RootCluster;

    fatType_ = 32;

  }

  return true;

}