path: root/os/io/mmc_spi.c

/*
    ChibiOS/RT - Copyright (C) 2006-2007 Giovanni Di Sirio.

    This file is part of ChibiOS/RT.

    ChibiOS/RT 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.

    ChibiOS/RT 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 this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/**
 * @file mmc_spi.c
 * @brief MMC over SPI driver code
 * @addtogroup MMC_SPI
 * @{
 */

#include <ch.h>
#include <spi.h>
#include <mmc_spi.h>

/*===========================================================================*/
/* Driver local functions.                                                   */
/*===========================================================================*/

void tmrfunc(void *p) {
  MMCDriver *mmcp = p;

  if (mmcp->mmc_cnt > 0) {
    if (mmcp->mmc_is_inserted()) {
      if (--mmcp->mmc_cnt == 0) {
        mmcp->mmc_state = MMC_INSERTED;
        chEvtBroadcastI(&mmcp->mmc_inserted_event);
      }
    }
    else
      mmcp->mmc_cnt = MMC_POLLING_INTERVAL;
  }
  else {
    if (!mmcp->mmc_is_inserted()) {
      mmcp->mmc_state = MMC_WAIT;
      mmcp->mmc_cnt = MMC_POLLING_INTERVAL;
      chEvtBroadcastI(&mmcp->mmc_removed_event);
    }
  }
  chVTSetI(&mmcp->mmc_vt, MS2ST(MMC_POLLING_DELAY), tmrfunc, mmcp);
}

/**
 * @brief Waits an idle condition.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 */
static void wait(MMCDriver *mmcp) {
  int i;
  uint8_t buf[4];

  for (i = 0; i < 16; i++) {
    spiReceive(mmcp->mmc_spip, 1, buf);
    if (buf[0] == 0xFF)
      break;
  }
  /* Looks like it is a long wait.*/
  while (TRUE) {
    spiReceive(mmcp->mmc_spip, 1, buf);
    if (buf[0] == 0xFF)
      break;
#ifdef MMC_NICE_WAITING
    /* Trying to be nice with the other threads.*/
    chThdSleep(1);
#endif
  }
}

/**
 * @brief Sends a command header.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 * @param cmd[in]       the command id
 * @param arg[in]       the command argument
 */
static void send_hdr(MMCDriver *mmcp, uint8_t cmd, uint32_t arg) {
  uint8_t buf[6];

  /* Wait for the bus to become idle if a write operation was in progress. */
  wait(mmcp);

  buf[0] = 0x40 | cmd;
  buf[1] = arg >> 24;
  buf[2] = arg >> 16;
  buf[3] = arg >> 8;
  buf[4] = arg;
  buf[5] = 0x95;        /* Valid for CMD0 ignored by other commands. */
  spiSend(mmcp->mmc_spip, 6, buf);
}

/**
 * @brief Receives a single byte response.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 *
 * @return The response as an @p uint8_t value.
 * @retval 0xFF         timed out.
 */
static uint8_t recvr1(MMCDriver *mmcp) {
  int i;
  uint8_t r1[1];

  for (i = 0; i < 9; i++) {
    spiReceive(mmcp->mmc_spip, 1, r1);
    if (r1[0] != 0xFF)
      return r1[0];
  }
  return 0xFF;
}

/**
 * @brief Sends a command an returns a single byte response.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 * @param cmd[in]       the command id
 * @param arg[in]       the command argument
 *
 * @return The response as an @p uint8_t value.
 * @retval 0xFF         timed out.
 */
static uint8_t send_command(MMCDriver *mmcp, uint8_t cmd, uint32_t arg) {
  uint8_t r1;

  spiSelect(mmcp->mmc_spip);
  send_hdr(mmcp, cmd, arg);
  r1 = recvr1(mmcp);
  spiUnselect(mmcp->mmc_spip);
  return r1;
}

/**
 * @brief Waits that the card reaches an idle state.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 */
static void sync(MMCDriver *mmcp) {
  uint8_t buf[1];

  spiSelect(mmcp->mmc_spip);
  while (TRUE) {
    spiReceive(mmcp->mmc_spip, 1, buf);
    if (buf[0] == 0xFF)
      break;
#ifdef MMC_NICE_WAITING
    chThdSleep(1);      /* Trying to be nice with the other threads.*/
#endif
  }
  spiUnselect(mmcp->mmc_spip);
}

/*===========================================================================*/
/* Driver exported functions.                                                */
/*===========================================================================*/

/**
 * @brief MMC over SPI driver initialization.
 */
void mmcInit(void) {

}

/**
 * @brief Initializes an instance.
 *
 * @param[in] mmcp          pointer to the @p MMCDriver object
 * @param[in] spip          pointer to the SPI driver to be used as interface
 * @param[in] lscfg         low speed configuration for the SPI driver
 * @param[in] hscfg         high speed configuration for the SPI driver
 * @param[in] is_protected  function that returns the card write protection
 *                          setting
 * @param[in] is_inserted   function that returns the card insertion sensor
 *                          status
 */
void mmcObjectInit(MMCDriver *mmcp, SPIDriver *spip,
                   const SPIConfig *lscfg, const SPIConfig *hscfg,
                   mmcquery_t is_protected, mmcquery_t is_inserted) {

  mmcp->mmc_state = MMC_STOP;
  mmcp->mmc_config = NULL;
  mmcp->mmc_spip = spip;
  mmcp->mmc_lscfg = lscfg;
  mmcp->mmc_hscfg = hscfg;
  mmcp->mmc_is_protected = is_protected;
  mmcp->mmc_is_inserted = is_inserted;
  chEvtInit(&mmcp->mmc_inserted_event);
  chEvtInit(&mmcp->mmc_removed_event);
}

/**
 * @brief Configures and activates the MMC peripheral.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 * @param[in] config    pointer to the @p MMCConfig object
 */
void mmcStart(MMCDriver *mmcp, const MMCConfig *config) {

  chDbgCheck((mmcp != NULL) && (config != NULL), "mmcStart");

  chSysLock();
  chDbgAssert(mmcp->mmc_state == MMC_STOP, "mmcStart(), #1", "invalid state");
  mmcp->mmc_config = config;
  mmcp->mmc_state = MMC_WAIT;
  mmcp->mmc_cnt = MMC_POLLING_INTERVAL;
  chVTSetI(&mmcp->mmc_vt, MS2ST(MMC_POLLING_DELAY), tmrfunc, mmcp);
  chSysUnlock();
}

/**
 * @brief Disables the MMC peripheral.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 */
void mmcStop(MMCDriver *mmcp) {

  chDbgCheck(mmcp != NULL, "mmcStop");

  chSysLock();
  chDbgAssert((mmcp->mmc_state != MMC_UNINIT) &&
              (mmcp->mmc_state != MMC_READING) &&
              (mmcp->mmc_state != MMC_WRITING),
              "mmcStop(), #1",
              "invalid state");
  if (mmcp->mmc_state != MMC_STOP) {
    mmcp->mmc_state = MMC_STOP;
    chVTResetI(&mmcp->mmc_vt);
  }
  chSysUnlock();
  spiStop(mmcp->mmc_spip);
}

/**
 * @brief Performs the initialization procedure on the inserted card.
 * @details This function should be invoked when a card is inserted and
 *          brings the driver in the @p MMC_READY state where it is possible
 *          to perform read and write operations.
 * @note It is possible to invoke this function from the insertion event
 *       handler.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 *
 * @return The operation status.
 * @retval FALSE        the operation was successful and the driver is now
 *                      in the @p MMC_READY state.
 * @retval TRUE         the operation failed.
 */
bool_t mmcConnect(MMCDriver *mmcp) {
  unsigned i;
  bool_t result;

  chDbgCheck(mmcp != NULL, "mmcConnect");

  chDbgAssert((mmcp->mmc_state != MMC_UNINIT) &&
              (mmcp->mmc_state != MMC_STOP),
              "mmcConnect(), #1",
              "invalid state");

  if (mmcp->mmc_state == MMC_INSERTED) {
    /* Slow clock mode and 128 clock pulses.*/
    spiStart(mmcp->mmc_spip, mmcp->mmc_lscfg);
    spiIgnore(mmcp->mmc_spip, 16);

    /* SPI mode selection.*/
    i = 0;
    while (TRUE) {
      if (send_command(mmcp, MMC_CMDGOIDLE, 0) == 0x01)
        break;
      if (++i >= MMC_CMD0_RETRY)
        return TRUE;
      chThdSleepMilliseconds(10);
    }

    /* Initialization. */
    i = 0;
    while (TRUE) {
      uint8_t b = send_command(mmcp, MMC_CMDINIT, 0);
      if (b == 0x00)
        break;
      if (b != 0x01)
        return TRUE;
      if (++i >= MMC_CMD1_RETRY)
        return TRUE;
      chThdSleepMilliseconds(10);
    }

    /* Initialization complete, full speed. */
    spiStart(mmcp->mmc_spip, mmcp->mmc_hscfg);

    /* Setting block size.*/
    if (send_command(mmcp, MMC_CMDSETBLOCKLEN, MMC_SECTOR_SIZE) != 0x00)
      return TRUE;

    /* Transition to MMC_READY state (if not extracted).*/
    chSysLock();
    if (mmcp->mmc_state == MMC_INSERTED) {
      mmcp->mmc_state = MMC_READY;
      result = FALSE;
    }
    else
      result = TRUE;
    chSysUnlock();
    return result;
  }
  if (mmcp->mmc_state == MMC_READY)
    return FALSE;
  /* Any other state is invalid.*/
  return TRUE;
}

/**
 * @brief Brings the driver in a state safe for card removal.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 * @return The operation status.
 * @retval FALSE        the operation was successful and the driver is now
 *                      in the @p MMC_INSERTED state.
 * @retval TRUE         the operation failed.
 */
bool_t mmcDisconnect(MMCDriver *mmcp) {

  chDbgCheck(mmcp != NULL, "mmcConnect");

  chDbgAssert((mmcp->mmc_state != MMC_UNINIT) &&
              (mmcp->mmc_state != MMC_STOP),
              "mmcDisconnect(), #1",
              "invalid state");
  switch (mmcp->mmc_state) {
  case MMC_READY:
    /* Wait for the pending write operations to complete.*/
    sync(mmcp);
    chSysLock();
    if (mmcp->mmc_state == MMC_READY)
      mmcp->mmc_state = MMC_INSERTED;
    chSysUnlock();
  case MMC_INSERTED:
    return FALSE;
  default:
    return TRUE;
  }
}

/**
 * @brief Starts a sequential read.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 * @param[in] startblk  first block to read
 *
 * @return The operation status.
 * @retval FALSE        the operation was successful.
 * @retval TRUE         the operation failed.
 */
bool_t mmcStartSequentialRead(MMCDriver *mmcp, uint32_t startblk) {

  chDbgCheck(mmcp != NULL, "mmcStartSequentialRead");

  chSysLock();
  if (mmcp->mmc_state != MMC_READY) {
    chSysUnlock();
    return TRUE;
  }
  mmcp->mmc_state = MMC_READING;
  chSysUnlock();

  spiSelect(mmcp->mmc_spip);
  send_hdr(mmcp, MMC_CMDREADMULTIPLE, startblk * MMC_SECTOR_SIZE);
  if (recvr1(mmcp) != 0x00) {
    spiUnselect(mmcp->mmc_spip);
    chSysLock();
    if (mmcp->mmc_state == MMC_READING)
      mmcp->mmc_state = MMC_READY;
    chSysUnlock();
    return TRUE;
  }
  return FALSE;
}

/**
 * @brief Reads a block within a sequential read operation.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 * @param[out] buffer   pointer to the read buffer
 *
 * @return The operation status.
 * @retval FALSE        the operation was successful.
 * @retval TRUE         the operation failed.
 */
bool_t mmcSequentialRead(MMCDriver *mmcp, uint8_t *buffer) {
  int i;

  chDbgCheck((mmcp != NULL) && (buffer != NULL), "mmcSequentialRead");

  chSysLock();
  if (mmcp->mmc_state != MMC_READING) {
    chSysUnlock();
    return TRUE;
  }
  chSysUnlock();

  for (i = 0; i < MMC_WAIT_DATA; i++) {
    spiReceive(mmcp->mmc_spip, 1, buffer);
    if (buffer[0] == 0xFE) {
      spiReceive(mmcp->mmc_spip, MMC_SECTOR_SIZE, buffer);
      /* CRC ignored. */
      spiIgnore(mmcp->mmc_spip, 2);
      return FALSE;
    }
  }
  /* Timeout.*/
  spiUnselect(mmcp->mmc_spip);
  chSysLock();
  if (mmcp->mmc_state == MMC_READING)
    mmcp->mmc_state = MMC_READY;
  chSysUnlock();
  return TRUE;
}

/**
 * @brief Stops a sequential read gracefully.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 *
 * @return The operation status.
 * @retval FALSE        the operation was successful.
 * @retval TRUE         the operation failed.
 */
bool_t mmcStopSequentialRead(MMCDriver *mmcp) {
  static const uint8_t stopcmd[] = {0x40 | MMC_CMDSTOP, 0, 0, 0, 0, 1, 0xFF};
  bool_t result;

  chDbgCheck(mmcp != NULL, "mmcStopSequentialRead");

  chSysLock();
  if (mmcp->mmc_state != MMC_READING) {
    chSysUnlock();
    return TRUE;
  }
  chSysUnlock();

  spiSend(mmcp->mmc_spip, sizeof(stopcmd), stopcmd);
  result = recvr1(mmcp) != 0x00;
  spiUnselect(mmcp->mmc_spip);

  chSysLock();
  if (mmcp->mmc_state == MMC_READING)
    mmcp->mmc_state = MMC_READY;
  chSysUnlock();
  return result;
}

/**
 * @brief Starts a sequential write.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 * @param[in] startblk  first block to write
 *
 * @return The operation status.
 * @retval FALSE        the operation was successful.
 * @retval TRUE         the operation failed.
 */
bool_t mmcStartSequentialWrite(MMCDriver *mmcp, uint32_t startblk) {

  chDbgCheck(mmcp != NULL, "mmcStartSequentialWrite");

  chSysLock();
  if (mmcp->mmc_state != MMC_READY) {
    chSysUnlock();
    return TRUE;
  }
  mmcp->mmc_state = MMC_WRITING;
  chSysUnlock();

  spiSelect(mmcp->mmc_spip);
  send_hdr(mmcp, MMC_CMDWRITEMULTIPLE, startblk * MMC_SECTOR_SIZE);
  if (recvr1(mmcp) != 0x00) {
    spiUnselect(mmcp->mmc_spip);
    chSysLock();
    if (mmcp->mmc_state == MMC_READING)
      mmcp->mmc_state = MMC_READY;
    chSysUnlock();
    return TRUE;
  }
  return FALSE;
}

/**
 * @brief Writes a block within a sequential write operation.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 * @param[out] buffer   pointer to the write buffer
 *
 * @return The operation status.
 * @retval FALSE        the operation was successful.
 * @retval TRUE         the operation failed.
 */
bool_t mmcSequentialWrite(MMCDriver *mmcp, const uint8_t *buffer) {
  static const uint8_t start[] = {0xFF, 0xFC};
  uint8_t b[1];

  chDbgCheck((mmcp != NULL) && (buffer != NULL), "mmcSequentialRead");

  chSysLock();
  if (mmcp->mmc_state != MMC_WRITING) {
    chSysUnlock();
    return TRUE;
  }
  chSysUnlock();

  spiSend(mmcp->mmc_spip, sizeof(start), start);    /* Data prologue.       */
  spiSend(mmcp->mmc_spip, MMC_SECTOR_SIZE, buffer); /* Data.                */
  spiIgnore(mmcp->mmc_spip, 2);                     /* CRC ignored.         */
  spiReceive(mmcp->mmc_spip, 1, b);
  if ((b[0] & 0x1F) == 0x05)
    return FALSE;

  /* Error.*/
  spiUnselect(mmcp->mmc_spip);
  chSysLock();
  if (mmcp->mmc_state == MMC_WRITING)
    mmcp->mmc_state = MMC_READY;
  chSysUnlock();
  return TRUE;
}

/**
 * @brief Stops a sequential write gracefully.
 *
 * @param[in] mmcp      pointer to the @p MMCDriver object
 *
 * @return The operation status.
 * @retval FALSE        the operation was successful.
 * @retval TRUE         the operation failed.
 */
bool_t mmcStopSequentialWrite(MMCDriver *mmcp) {
  static const uint8_t stop[] = {0xFD, 0xFF};

  chDbgCheck(mmcp != NULL, "mmcStopSequentialWrite");

  chSysLock();
  if (mmcp->mmc_state != MMC_WRITING) {
    chSysUnlock();
    return TRUE;
  }
  chSysUnlock();

  spiSend(mmcp->mmc_spip, sizeof(stop), stop);
  spiUnselect(mmcp->mmc_spip);

  chSysLock();
  if (mmcp->mmc_state == MMC_WRITING)
    mmcp->mmc_state = MMC_READY;
  chSysUnlock();
  return TRUE;
}

/** @} */