234 lines
7.2 KiB
C++
234 lines
7.2 KiB
C++
/**
|
|
* Copyright (c) 2011-2018 Bill Greiman
|
|
* This file is part of the SdFat library for SD memory cards.
|
|
*
|
|
* MIT License
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included
|
|
* in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
#include "SdSpiDriver.h"
|
|
#if defined(__arm__) && defined(CORE_TEENSY)
|
|
// SPI definitions
|
|
// #include "kinetis.h"
|
|
|
|
//------------------------------------------------------------------------------
|
|
void SdSpiAltDriver::activate() {
|
|
SPI.beginTransaction(m_spiSettings);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void SdSpiAltDriver::begin(uint8_t chipSelectPin) {
|
|
m_csPin = chipSelectPin;
|
|
pinMode(m_csPin, OUTPUT);
|
|
digitalWrite(m_csPin, HIGH);
|
|
SPI.begin();
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void SdSpiAltDriver::deactivate() {
|
|
SPI.endTransaction();
|
|
}
|
|
//==============================================================================
|
|
#ifdef KINETISK
|
|
|
|
// use 16-bit frame if SPI_USE_8BIT_FRAME is zero
|
|
#define SPI_USE_8BIT_FRAME 0
|
|
// Limit initial fifo to three entries to avoid fifo overrun
|
|
#define SPI_INITIAL_FIFO_DEPTH 3
|
|
// define some symbols that are not in mk20dx128.h
|
|
#ifndef SPI_SR_RXCTR
|
|
#define SPI_SR_RXCTR 0XF0
|
|
#endif // SPI_SR_RXCTR
|
|
#ifndef SPI_PUSHR_CONT
|
|
#define SPI_PUSHR_CONT 0X80000000
|
|
#endif // SPI_PUSHR_CONT
|
|
#ifndef SPI_PUSHR_CTAS
|
|
#define SPI_PUSHR_CTAS(n) (((n) & 7) << 28)
|
|
#endif // SPI_PUSHR_CTAS
|
|
//------------------------------------------------------------------------------
|
|
/** SPI receive a byte */
|
|
uint8_t SdSpiAltDriver::receive() {
|
|
SPI0_MCR |= SPI_MCR_CLR_RXF;
|
|
SPI0_SR = SPI_SR_TCF;
|
|
SPI0_PUSHR = 0xFF;
|
|
while (!(SPI0_SR & SPI_SR_TCF)) {}
|
|
return SPI0_POPR;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** SPI receive multiple bytes */
|
|
uint8_t SdSpiAltDriver::receive(uint8_t* buf, size_t n) {
|
|
// clear any data in RX FIFO
|
|
SPI0_MCR = SPI_MCR_MSTR | SPI_MCR_CLR_RXF | SPI_MCR_PCSIS(0x1F);
|
|
#if SPI_USE_8BIT_FRAME
|
|
// initial number of bytes to push into TX FIFO
|
|
int nf = n < SPI_INITIAL_FIFO_DEPTH ? n : SPI_INITIAL_FIFO_DEPTH;
|
|
for (int i = 0; i < nf; i++) {
|
|
SPI0_PUSHR = 0XFF;
|
|
}
|
|
// limit for pushing dummy data into TX FIFO
|
|
uint8_t* limit = buf + n - nf;
|
|
while (buf < limit) {
|
|
while (!(SPI0_SR & SPI_SR_RXCTR)) {}
|
|
SPI0_PUSHR = 0XFF;
|
|
*buf++ = SPI0_POPR;
|
|
}
|
|
// limit for rest of RX data
|
|
limit += nf;
|
|
while (buf < limit) {
|
|
while (!(SPI0_SR & SPI_SR_RXCTR)) {}
|
|
*buf++ = SPI0_POPR;
|
|
}
|
|
#else // SPI_USE_8BIT_FRAME
|
|
// use 16 bit frame to avoid TD delay between frames
|
|
// get one byte if n is odd
|
|
if (n & 1) {
|
|
*buf++ = receive();
|
|
n--;
|
|
}
|
|
// initial number of words to push into TX FIFO
|
|
int nf = n/2 < SPI_INITIAL_FIFO_DEPTH ? n/2 : SPI_INITIAL_FIFO_DEPTH;
|
|
for (int i = 0; i < nf; i++) {
|
|
SPI0_PUSHR = SPI_PUSHR_CONT | SPI_PUSHR_CTAS(1) | 0XFFFF;
|
|
}
|
|
uint8_t* limit = buf + n - 2*nf;
|
|
while (buf < limit) {
|
|
while (!(SPI0_SR & SPI_SR_RXCTR)) {}
|
|
SPI0_PUSHR = SPI_PUSHR_CONT | SPI_PUSHR_CTAS(1) | 0XFFFF;
|
|
uint16_t w = SPI0_POPR;
|
|
*buf++ = w >> 8;
|
|
*buf++ = w & 0XFF;
|
|
}
|
|
// limit for rest of RX data
|
|
limit += 2*nf;
|
|
while (buf < limit) {
|
|
while (!(SPI0_SR & SPI_SR_RXCTR)) {}
|
|
uint16_t w = SPI0_POPR;
|
|
*buf++ = w >> 8;
|
|
*buf++ = w & 0XFF;
|
|
}
|
|
#endif // SPI_USE_8BIT_FRAME
|
|
return 0;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** SPI send a byte */
|
|
void SdSpiAltDriver::send(uint8_t b) {
|
|
SPI0_MCR |= SPI_MCR_CLR_RXF;
|
|
SPI0_SR = SPI_SR_TCF;
|
|
SPI0_PUSHR = b;
|
|
while (!(SPI0_SR & SPI_SR_TCF)) {}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** SPI send multiple bytes */
|
|
void SdSpiAltDriver::send(const uint8_t* buf , size_t n) {
|
|
// clear any data in RX FIFO
|
|
SPI0_MCR = SPI_MCR_MSTR | SPI_MCR_CLR_RXF | SPI_MCR_PCSIS(0x1F);
|
|
#if SPI_USE_8BIT_FRAME
|
|
// initial number of bytes to push into TX FIFO
|
|
int nf = n < SPI_INITIAL_FIFO_DEPTH ? n : SPI_INITIAL_FIFO_DEPTH;
|
|
// limit for pushing data into TX fifo
|
|
const uint8_t* limit = buf + n;
|
|
for (int i = 0; i < nf; i++) {
|
|
SPI0_PUSHR = *buf++;
|
|
}
|
|
// write data to TX FIFO
|
|
while (buf < limit) {
|
|
while (!(SPI0_SR & SPI_SR_RXCTR)) {}
|
|
SPI0_PUSHR = *buf++;
|
|
SPI0_POPR;
|
|
}
|
|
// wait for data to be sent
|
|
while (nf) {
|
|
while (!(SPI0_SR & SPI_SR_RXCTR)) {}
|
|
SPI0_POPR;
|
|
nf--;
|
|
}
|
|
#else // SPI_USE_8BIT_FRAME
|
|
// use 16 bit frame to avoid TD delay between frames
|
|
// send one byte if n is odd
|
|
if (n & 1) {
|
|
send(*buf++);
|
|
n--;
|
|
}
|
|
// initial number of words to push into TX FIFO
|
|
int nf = n/2 < SPI_INITIAL_FIFO_DEPTH ? n/2 : SPI_INITIAL_FIFO_DEPTH;
|
|
// limit for pushing data into TX fifo
|
|
const uint8_t* limit = buf + n;
|
|
for (int i = 0; i < nf; i++) {
|
|
uint16_t w = (*buf++) << 8;
|
|
w |= *buf++;
|
|
SPI0_PUSHR = SPI_PUSHR_CONT | SPI_PUSHR_CTAS(1) | w;
|
|
}
|
|
// write data to TX FIFO
|
|
while (buf < limit) {
|
|
uint16_t w = *buf++ << 8;
|
|
w |= *buf++;
|
|
while (!(SPI0_SR & SPI_SR_RXCTR)) {}
|
|
SPI0_PUSHR = SPI_PUSHR_CONT | SPI_PUSHR_CTAS(1) | w;
|
|
SPI0_POPR;
|
|
}
|
|
// wait for data to be sent
|
|
while (nf) {
|
|
while (!(SPI0_SR & SPI_SR_RXCTR)) {}
|
|
SPI0_POPR;
|
|
nf--;
|
|
}
|
|
#endif // SPI_USE_8BIT_FRAME
|
|
}
|
|
#else // KINETISK
|
|
//==============================================================================
|
|
// Use standard SPI library if not KINETISK
|
|
//------------------------------------------------------------------------------
|
|
/** Receive a byte.
|
|
*
|
|
* \return The byte.
|
|
*/
|
|
uint8_t SdSpiAltDriver::receive() {
|
|
return SPI.transfer(0XFF);
|
|
}
|
|
/** Receive multiple bytes.
|
|
*
|
|
* \param[out] buf Buffer to receive the data.
|
|
* \param[in] n Number of bytes to receive.
|
|
*
|
|
* \return Zero for no error or nonzero error code.
|
|
*/
|
|
uint8_t SdSpiAltDriver::receive(uint8_t* buf, size_t n) {
|
|
for (size_t i = 0; i < n; i++) {
|
|
buf[i] = SPI.transfer(0XFF);
|
|
}
|
|
return 0;
|
|
}
|
|
/** Send a byte.
|
|
*
|
|
* \param[in] b Byte to send
|
|
*/
|
|
void SdSpiAltDriver::send(uint8_t b) {
|
|
SPI.transfer(b);
|
|
}
|
|
/** Send multiple bytes.
|
|
*
|
|
* \param[in] buf Buffer for data to be sent.
|
|
* \param[in] n Number of bytes to send.
|
|
*/
|
|
void SdSpiAltDriver::send(const uint8_t* buf , size_t n) {
|
|
for (size_t i = 0; i < n; i++) {
|
|
SPI.transfer(buf[i]);
|
|
}
|
|
}
|
|
#endif // KINETISK
|
|
#endif // defined(__arm__) && defined(CORE_TEENSY)
|