mmc.c

/* mmc.c: Emulation of the SD / MMC interface
   Copyright (c) 2017 Philip Kendall

   This program 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 2 of the License, or
   (at your option) any later version.

   This program 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, write to the Free Software Foundation, Inc.,
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

   Author contact information:

   E-mail: Philip Kendall <philip-fuse@shadowmagic.org.uk>

*/

#include "config.h"

#include <stdio.h>
#include <string.h>

#include "internals.h"

#define IN_IDLE_STATE_MASK   0x01
#define ERASE_RESET_MASK     0x02
#define ILLEGAL_COMMAND_MASK 0x04
#define ERASE_SEQ_ERROR_MASK 0x10
#define PARAMETER_ERROR_MASK 0x40

/* The states while a command is being sent to the card */
enum command_state_t {
  WAITING_FOR_COMMAND,
  WAITING_FOR_DATA0,
  WAITING_FOR_DATA1,
  WAITING_FOR_DATA2,
  WAITING_FOR_DATA3,
  WAITING_FOR_CRC,
  WAITING_FOR_DATA_TOKEN,
  WAITING_FOR_DATA,
  WAITING_FOR_DATA_CRC1,
  WAITING_FOR_DATA_CRC2
};

/* The MMC commands we support */
enum command_byte {
  GO_IDLE_STATE = 0,
  SEND_IF_COND = 8,
  SEND_CSD = 9,
  SEND_CID = 10,
  READ_SINGLE_BLOCK = 17,
  WRITE_BLOCK = 24,
  ERASE_WR_BLK_START = 32,
  ERASE_WR_BLK_END = 33,
  ERASE = 38,
  APP_CMD = 55,
  READ_OCR = 58
};

/* Application specific commands, only some implemented
   but needed for command identification */
enum application_command_byte {
  SD_STATUS = 13,
  SEND_NUM_WR_BLOCKS = 22,
  SET_WR_BLK_ERASE_COUNT = 23,
  SD_SEND_OP_COND = 41,
  SET_CLR_CARD_DETECT = 42,
  SEND_SCR = 51,
};

/* The state of an erase sequence */
enum erase_sequence_t {
  SEQ_ERASE_NONE,
  SEQ_ERASE_WR_BLK_START,
  SEQ_ERASE_WR_BLK_END,
};

struct libspectrum_mmc_card {
  /* The actual "card" data */
  libspectrum_ide_drive drive;

  /* Cache of written sectors */
  GHashTable *cache;

  /* The C_SIZE field of the card CSD */
  libspectrum_word c_size;

  /* The number of sectors (512 bytes) */
  libspectrum_dword total_sectors;

  /* R1 status of current command */
  libspectrum_byte r1_status;

  /* The current state of the command being transmitted to the card */
  enum command_state_t command_state;

  /* The most recent command index sent to the MMC */
  libspectrum_byte current_command;

  /* The argument for the current MMC command */
  libspectrum_byte current_argument[4];

  /* How much data has been sent for the current command */
  size_t data_count;

  /* The data for the current command */
  libspectrum_byte send_buffer[512];

  /* The response to the most recent command */
  libspectrum_byte response_buffer[516];

  /* One past the last valid byte in response_buffer */
  libspectrum_byte *response_buffer_end;

  /* The next byte to be returned from response_buffer */
  libspectrum_byte *response_buffer_next;

  /* CMD8/SEND_IF_COND recieved while initialising */
  int cmd8_issued;

  /* CMD55/APP_CMD issued so next command is application specific */
  int cmd55_issued;

  /* Keep progress of ongoing erase sequence */
  enum erase_sequence_t erase_sequence;

  /* Initial and end blocks of programmed erase */
  libspectrum_dword erase_block_start, erase_block_end;

};

libspectrum_mmc_card*
libspectrum_mmc_alloc( void )
{
  libspectrum_mmc_card *card = libspectrum_new( libspectrum_mmc_card, 1 );

  card->drive.disk = NULL;
  card->cache = g_hash_table_new( g_int_hash, g_int_equal );

  libspectrum_mmc_reset( card );

  return card;
}

void
libspectrum_mmc_free( libspectrum_mmc_card *card )
{
  libspectrum_mmc_eject( card );

  g_hash_table_destroy( card->cache );

  libspectrum_free( card );
}

libspectrum_error
libspectrum_mmc_insert( libspectrum_mmc_card *card, const char *filename )
{
  libspectrum_error error;
  libspectrum_dword c_size;

  libspectrum_mmc_eject( card );
  if( !filename ) return LIBSPECTRUM_ERROR_NONE;

  error = libspectrum_ide_insert_into_drive( &card->drive, filename );
  if( error ) return error;

  card->total_sectors = (libspectrum_dword)card->drive.cylinders *
    card->drive.heads * card->drive.sectors;

  if( card->drive.sector_size != 512 || card->total_sectors % 1024 ) {
      libspectrum_print_error( LIBSPECTRUM_ERROR_UNKNOWN,
        "Image size not supported" );
    return LIBSPECTRUM_ERROR_UNKNOWN;
  }

  /* memory capacity = (C_SIZE+1) * 512K bytes
     we reduce the sector count by 1024. This gives us a minimum card size
     of 512 Kb. Not too worried about that. */
  c_size = ( card->total_sectors >> 10 ) - 1;

  /* We emulate a SDHC card which has a maximum size of (32 Gb - 80 Mb) */
  if( c_size >= 65375 ) {
    libspectrum_print_error( LIBSPECTRUM_ERROR_UNKNOWN,
      "Image size too big (>32 Gb)" );
    return LIBSPECTRUM_ERROR_UNKNOWN;
  }

  card->c_size = c_size;

  return LIBSPECTRUM_ERROR_NONE;
}

void
libspectrum_mmc_eject( libspectrum_mmc_card *card )
{
  libspectrum_ide_eject_from_drive( &card->drive, card->cache );
  libspectrum_mmc_reset( card );
}

void
libspectrum_mmc_reset( libspectrum_mmc_card *card )
{
  card->r1_status = IN_IDLE_STATE_MASK;
  card->command_state = WAITING_FOR_COMMAND;
  card->response_buffer_next = card->response_buffer;
  card->response_buffer_end = card->response_buffer;
  card->cmd8_issued = 0;
  card->cmd55_issued = 0;
  card->erase_sequence = SEQ_ERASE_NONE;
  card->erase_block_start = 0;
  card->erase_block_end = 0;
}

int
libspectrum_mmc_dirty( libspectrum_mmc_card *card )
{
  return g_hash_table_size( card->cache ) != 0;
}

void
libspectrum_mmc_commit( libspectrum_mmc_card *card )
{
  libspectrum_ide_commit_drive( &card->drive, card->cache );
}

libspectrum_byte
libspectrum_mmc_read( libspectrum_mmc_card *card )
{
  libspectrum_byte r = card->response_buffer_next < card->response_buffer_end ?
    *(card->response_buffer_next)++ :
    0xff;

  return r;
}

static int
parse_command( libspectrum_mmc_card *card, libspectrum_byte b )
{
  /* All commands should have start bit == 0 and transmitter bit == 1 */
  if( ( b & 0xc0 ) != 0x40 ) return 0;  /* don't change current state */

  /* Unlike the SD Memory Card protocol, in the SPI mode, the card will always
     respond to a command. The response indicates acceptance or rejection of
     the command. Now wait for arguments and CRC */
  card->current_command = b & 0x3f;
  return 1;
}

static void
set_response_buffer_r1( libspectrum_mmc_card *card )
{
  card->response_buffer[ 0 ] = card->r1_status;
  card->response_buffer_next = card->response_buffer;
  card->response_buffer_end = card->response_buffer + 1;
}

static void
set_response_buffer_r7( libspectrum_mmc_card *card, libspectrum_dword value )
{
  card->response_buffer[ 0 ] = card->r1_status;
  card->response_buffer[ 1 ] = ( value & 0xff000000 ) >> 24;
  card->response_buffer[ 2 ] = ( value & 0x00ff0000 ) >> 16;
  card->response_buffer[ 3 ] = ( value & 0x0000ff00 ) >>  8;
  card->response_buffer[ 4 ] = ( value & 0x000000ff );
  card->response_buffer_next = card->response_buffer;
  card->response_buffer_end = card->response_buffer + 5;
}

static void
reset_erase_sequence( libspectrum_mmc_card *card )
{
  card->erase_sequence = SEQ_ERASE_NONE;
  card->erase_block_start = 0;
  card->erase_block_end = 0;
}

static void
erase_wr_blk_start( libspectrum_mmc_card *card )
{
  /* Card initialised? */
  if( card->r1_status & IN_IDLE_STATE_MASK ) {
    card->r1_status |= ILLEGAL_COMMAND_MASK;
    set_response_buffer_r1( card );
    return;
  }

  /* Check erase sequence */
  if( card->erase_sequence != SEQ_ERASE_NONE ) {
    card->r1_status |= ERASE_SEQ_ERROR_MASK;
    set_response_buffer_r1( card );
    reset_erase_sequence( card );
    return;
  }

  card->erase_block_start =
    card->current_argument[ 3 ] +
    (card->current_argument[ 2 ] << 8) +
    (card->current_argument[ 1 ] << 16) +
    (card->current_argument[ 0 ] << 24);

  /* Sector out of range */
  if( card->erase_block_start >= card->total_sectors ) {
    card->r1_status |= PARAMETER_ERROR_MASK;
    set_response_buffer_r1( card );
    reset_erase_sequence( card );
    return;
  }

  set_response_buffer_r1( card );
  card->erase_sequence = SEQ_ERASE_WR_BLK_START;
}

static void
erase_wr_blk_end( libspectrum_mmc_card *card )
{
  /* Card initialised? */
  if( card->r1_status & IN_IDLE_STATE_MASK ) {
    card->r1_status |= ILLEGAL_COMMAND_MASK;
    set_response_buffer_r1( card );
    return;
  }

  /* Check erase sequence */
  if( card->erase_sequence != SEQ_ERASE_WR_BLK_START ) {
    card->r1_status |= ERASE_SEQ_ERROR_MASK;
    set_response_buffer_r1( card );
    reset_erase_sequence( card );
    return;
  }

  card->erase_block_end =
    card->current_argument[ 3 ] +
    (card->current_argument[ 2 ] << 8) +
    (card->current_argument[ 1 ] << 16) +
    (card->current_argument[ 0 ] << 24);

  /* Sector out of range */
  if( card->erase_block_end >= card->total_sectors ) {
    card->r1_status |= PARAMETER_ERROR_MASK;
    set_response_buffer_r1( card );
    reset_erase_sequence( card );
    return;
  }

  /* Check continuous range */
  if( card->erase_block_start > card->erase_block_end ) {
    card->r1_status |= PARAMETER_ERROR_MASK;
    set_response_buffer_r1( card );
    reset_erase_sequence( card );
    return;
  }

  set_response_buffer_r1( card );
  card->erase_sequence = SEQ_ERASE_WR_BLK_END;
}

static void
erase( libspectrum_mmc_card *card )
{
  libspectrum_dword i;

  /* Card initialised? */
  if( card->r1_status & IN_IDLE_STATE_MASK ) {
    card->r1_status |= ILLEGAL_COMMAND_MASK;
    set_response_buffer_r1( card );
    return;
  }

  /* Check erase sequence */
  if( card->erase_sequence != SEQ_ERASE_WR_BLK_END ) {
    card->r1_status |= ERASE_SEQ_ERROR_MASK;
    set_response_buffer_r1( card );
    reset_erase_sequence( card );
    return;
  }

  /* The data at the card after an erase operation is either '0' or '1',
     depends on the card vendor */
  memset( card->send_buffer, 0x00, 512 );

  for( i = card->erase_block_start; i <= card->erase_block_end; i++ ) {
    libspectrum_ide_write_sector_to_hdf( &card->drive, card->cache, i,
                                         card->send_buffer );
  }

  card->response_buffer[ 0 ] = card->r1_status; /* R1 command response */
  card->response_buffer[ 1 ] = 0x01;            /* busy flag */
  card->response_buffer_next = card->response_buffer;
  card->response_buffer_end = card->response_buffer + 2;

  reset_erase_sequence( card );
}

static void
read_single_block( libspectrum_mmc_card *card )
{
  libspectrum_dword sector_number;

  /* Card initialised? */
  if( card->r1_status & IN_IDLE_STATE_MASK ) {
    card->r1_status |= ILLEGAL_COMMAND_MASK;
    set_response_buffer_r1( card );
    return;
  }

  sector_number =
    card->current_argument[ 3 ] +
    (card->current_argument[ 2 ] << 8) +
    (card->current_argument[ 1 ] << 16) +
    (card->current_argument[ 0 ] << 24);

  /* Sector out of range */
  if( sector_number >= card->total_sectors ) {
    card->r1_status |= PARAMETER_ERROR_MASK;
    set_response_buffer_r1( card );
    return;
  }

  int error = libspectrum_ide_read_sector_from_hdf(
      &card->drive, card->cache, sector_number, &card->response_buffer[ 2 ]
  );

  /* Data retrieval error */
  if( error ) {
    card->response_buffer[ 0 ] = card->r1_status; /* R1 command response */
    card->response_buffer[ 1 ] = 0x01;            /* data error token */
    card->response_buffer_next = card->response_buffer;
    card->response_buffer_end = card->response_buffer + 2;
    return;
  }

  card->response_buffer[ 0 ] = card->r1_status;
  card->response_buffer[ 1 ] = 0xfe;

  /* CRC */
  memset( &card->response_buffer[ 514 ], 0x00, 2 );

  card->response_buffer_next = card->response_buffer;
  card->response_buffer_end = card->response_buffer + 516;
}

static void
send_csd( libspectrum_mmc_card *card )
{
  /* Card initialised? */
  if( card->r1_status & IN_IDLE_STATE_MASK ) {
    card->r1_status |= ILLEGAL_COMMAND_MASK;
    set_response_buffer_r1( card );
    return;
  }

  card->response_buffer[ 0 ] = card->r1_status; /* R1 command response */
  card->response_buffer[ 1 ] = 0xfe;            /* data token */

  memset( &card->response_buffer[ 2 ], 0x00, 16 );

  /* CSD_STRUCTURE version 2.0 */
  card->response_buffer[ 2 ] = 0x40;

  /* CCC card command classes (spread 8 bits, 4 bits across two bytes) */
  card->response_buffer[ 2 +  4 ] = 0x5b;
  card->response_buffer[ 2 +  5 ] = 0x05;

  /* READ_BL_LEN = 9 => 2 ^ 9 = 512 byte sectors */
  card->response_buffer[ 2 +  5 ] |= 0x09;

  /* C_SIZE (spread 6 bits, 8 bits, 8 bits across three bytes),
     first 6 bits set to zero */
  card->response_buffer[ 2 +  8 ] = ( card->c_size >> 8 ) & 0xff;
  card->response_buffer[ 2 +  9 ] = card->c_size & 0xff;

  /* ERASE_BLK_EN (1 bit ) */
  card->response_buffer[ 2 +  10 ] = 0x40;

  /* SECTOR_SIZE (spread 7 bits, 1 bit across two bytes) */
  card->response_buffer[ 2 +  10 ] |= 0x3f;
  card->response_buffer[ 2 +  11 ]  = 0x80;

  /* WRITE_BL_LEN = 9 => 2 ^ 9 = 512 byte sectors
     (spread 2 bits, 2 bits across two bytes) */
  card->response_buffer[ 2 +  12 ] = 0x10;
  card->response_buffer[ 2 +  13 ] = 0x01;

  /* Bit 0, not used, always 1 */
  card->response_buffer[ 2 +  15 ] = 0x01;

  /* CRC */
  memset( &card->response_buffer[ 18 ], 0x00, 2 );

  card->response_buffer_next = card->response_buffer;
  card->response_buffer_end = card->response_buffer + 20;
}

static void
send_cid( libspectrum_mmc_card *card )
{
  /* Card initialised? */
  if( card->r1_status & IN_IDLE_STATE_MASK ) {
    card->r1_status |= ILLEGAL_COMMAND_MASK;
    set_response_buffer_r1( card );
    return;
  }

  card->response_buffer[ 0 ] = card->r1_status; /* R1 command response */
  card->response_buffer[ 1 ] = 0xfe;            /* data token */

  /* For now, we return a mostly empty CID. This seems to work. */
  memset( &card->response_buffer[ 2 ], 0x00, 16 );

  /* Set blank OID */
  memcpy( &card->response_buffer[ 2 + 1 ], "  ", 2 );

  /* Set product name */
  memcpy( &card->response_buffer[ 2 + 3 ], "Fuse", 4 );

  /* Bit 0, not used, always 1 */
  card->response_buffer[ 2 +  15 ] = 0x01;

  /* CRC */
  memset( &card->response_buffer[ 18 ], 0x00, 2 );

  card->response_buffer_next = card->response_buffer;
  card->response_buffer_end = card->response_buffer + 20;
}

static int
do_application_command( libspectrum_mmc_card *card )
{
  int is_acmd = 1;

  switch( card->current_command ) {
    case SD_STATUS:
    case SEND_NUM_WR_BLOCKS:
    case SET_WR_BLK_ERASE_COUNT:
    case SET_CLR_CARD_DETECT:
    case SEND_SCR:
      /* Application command not implemented, return illegal command for now */
      card->r1_status |= ILLEGAL_COMMAND_MASK;
      set_response_buffer_r1( card );

      libspectrum_print_error(
          LIBSPECTRUM_ERROR_UNKNOWN,
          "Unknown MMC application command %d received",
          card->current_command );
      break;

    case SD_SEND_OP_COND:
      /* SDHC cards return in_idle_state=1 when:
         1. CMD8 was not issued before ACMD41
         2. ACMD41 is issued with HCS=0 (host only supports SDSC)
      */
      if( card->cmd8_issued && ( card->current_argument[ 0 ] & 0x40 ) ) {
        card->r1_status &= ~IN_IDLE_STATE_MASK;
      }
      set_response_buffer_r1( card );
      break;

    default:
      is_acmd = 0;
      break;
  }

  return is_acmd;
}

static void
do_standard_command( libspectrum_mmc_card *card )
{
  switch( card->current_command ) {
    case GO_IDLE_STATE:
      card->r1_status |= IN_IDLE_STATE_MASK;
      card->cmd8_issued = 0;
      set_response_buffer_r1( card );
      break;
    case SEND_IF_COND:
      card->cmd8_issued = 1;

      /* return echo back pattern */
      set_response_buffer_r7( card, 0x00000100 | card->current_argument[ 3 ] );
      break;
    case SEND_CSD:
      send_csd( card );
      break;
    case SEND_CID:
      send_cid( card );
      break;
    case READ_SINGLE_BLOCK:
      read_single_block( card );
      break;
    case WRITE_BLOCK:
      set_response_buffer_r1( card );
      break;
    case ERASE_WR_BLK_START:
      erase_wr_blk_start( card );
      break;
    case ERASE_WR_BLK_END:
      erase_wr_blk_end( card );
      break;
    case ERASE:
      erase( card );
      break;
    case APP_CMD:
      card->cmd55_issued = 1;
      set_response_buffer_r1( card );
      break;
    case READ_OCR:
      /* We set only the card capacity status (CCS, bit 30) and card power up
         status bits (bit 31). CCS set indicates an SDHC card. */
      set_response_buffer_r7( card, 0xc0000000 );
      break;
    default:
      /* Command not implemented or illegal command */
      card->r1_status |= ILLEGAL_COMMAND_MASK;
      set_response_buffer_r1( card );

      libspectrum_print_error(
          LIBSPECTRUM_ERROR_UNKNOWN, "Unknown MMC command %d received",
          card->current_command );
      break;
  }
}

static void
do_command( libspectrum_mmc_card *card )
{
  /* Previous APP_CMD indicates to the card that the next command is an
     application specific command rather than a standard command */
  if( card->cmd55_issued ) {
    card->cmd55_issued = 0;

    /* If a non-ACMD is sent, then it is respected by the card as a normal
       SD Memory Card command */
    if( do_application_command( card ) )
      return;
  }

  /* Check ongoing erase sequence */
  if( card->erase_sequence != SEQ_ERASE_NONE ) {
    switch( card->current_command ) {
      case ERASE_WR_BLK_START:
      case ERASE_WR_BLK_END:
      case ERASE:
        break;
      default:
        /* Clear erase sequence before executing because an out of erase
           sequence command was received */
        reset_erase_sequence( card );
        card->r1_status |= ERASE_RESET_MASK;
        break;
    }
  }

  do_standard_command( card );
}

static void
write_single_block( libspectrum_mmc_card *card )
{
  libspectrum_dword sector_number;

  /* Card initialised? */
  if( card->r1_status & IN_IDLE_STATE_MASK ) {
    card->r1_status |= ILLEGAL_COMMAND_MASK;
    set_response_buffer_r1( card );
    return;
  }

  sector_number =
    card->current_argument[ 3 ] +
    (card->current_argument[ 2 ] << 8) +
    (card->current_argument[ 1 ] << 16) +
    (card->current_argument[ 0 ] << 24);

  /* Sector out of range */
  if( sector_number >= card->total_sectors ) {
    card->r1_status |= PARAMETER_ERROR_MASK;
    set_response_buffer_r1( card );
    return;
  }

  libspectrum_ide_write_sector_to_hdf( &card->drive, card->cache, sector_number,
                                       card->send_buffer );

  card->response_buffer[ 0 ] = 0x05; /* data response */
  card->response_buffer[ 1 ] = 0x01; /* busy flag (end of programming) */
  card->response_buffer_next = card->response_buffer;
  card->response_buffer_end = card->response_buffer + 2;
}

static void
do_command_data( libspectrum_mmc_card *card )
{
  switch( card->current_command ) {
    case WRITE_BLOCK:
      write_single_block( card );
      break;
    default:
      /* This should never happen as it indicates a failure in our state machine */
      libspectrum_print_error(
          LIBSPECTRUM_ERROR_LOGIC,
          "Attempting to execute unknown MMC data command %d\n",
          card->current_command );
      break;
  }
}

void
libspectrum_mmc_write( libspectrum_mmc_card *card, libspectrum_byte data )
{
  /* No card inserted => no change in state */
  if( !card->drive.disk ) return;

  switch( card->command_state ) {
    case WAITING_FOR_COMMAND:
      if( parse_command( card, data ) )
        card->command_state = WAITING_FOR_DATA0;
      break;
    case WAITING_FOR_DATA0:
    case WAITING_FOR_DATA1:
    case WAITING_FOR_DATA2:
    case WAITING_FOR_DATA3:
      card->current_argument[ card->command_state - 1 ] = data;
      card->command_state++;
      break;
    case WAITING_FOR_CRC:
      /* We ignore the CRC */
      do_command( card );

      /* reset command error flags except in_idle */
      card->r1_status &= IN_IDLE_STATE_MASK;

      card->command_state = card->current_command == WRITE_BLOCK ?
        WAITING_FOR_DATA_TOKEN :
        WAITING_FOR_COMMAND;
      break;
    case WAITING_FOR_DATA_TOKEN:
      if( data == 0xfe ) {
        card->command_state = WAITING_FOR_DATA;
        card->data_count = 0;
      }
      break;
    case WAITING_FOR_DATA:
      card->send_buffer[ card->data_count++ ] = data;
      if( card->data_count == 512 )
        card->command_state = WAITING_FOR_DATA_CRC1;
      break;
    case WAITING_FOR_DATA_CRC1:
      /* We ignore the data CRC as well */
      card->command_state = WAITING_FOR_DATA_CRC2;
      break;
    case WAITING_FOR_DATA_CRC2:
      do_command_data( card );
      card->command_state = WAITING_FOR_COMMAND;
      break;
    }
}