Moving all AVR specific libraries to hardware/avr

1 files changed, 295 insertions, 0 deletions

diff --git a/libraries/SD/utility/SdVolume.cpp b/libraries/SD/utility/SdVolume.cpp
new file mode 100644
index 0000000..ece4acb
--- /dev/null
+++ b/libraries/SD/utility/SdVolume.cpp
@@ -0,0 +1,295 @@
+/* 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;

+}