/*C**************************************************************************
* NAME:         mem_task.c
*----------------------------------------------------------------------------
* Copyright (c) 2002 Atmel.
*----------------------------------------------------------------------------
* RELEASE:      snd1c-refd-nf-3_2_1      
* REVISION:     1.5.2.10     
*----------------------------------------------------------------------------
* PURPOSE:
* This file contains the memory task and attached routines
*
* NOTES:
* Global Variables:
*   - gl_memory:    bit in bdata space
*   - gl_mem_tick:  byte in data space
*****************************************************************************/

/*_____ I N C L U D E S ____________________________________________________*/

#include "config.h"                         /* system configuration */
#include "modules\display\disp.h"           /* display definition */
#include "modules\file\file.h"              /* file definition */
#include "hard.h"                           /* low level function definition */
#include "mem_task.h"                       /* memory task definition */


/*_____ M A C R O S ________________________________________________________*/


/*_____ D E F I N I T I O N ________________________________________________*/

extern  bdata   bit     gl_memory;          /* selected memory */
extern  data    Byte    gl_mem_tick;        /* memory tick counter */

        Byte    mem_state;                  /* task state */
static  bit     mem_force_mmc;

/*_____ D E C L A R A T I O N ______________________________________________*/


/*F**************************************************************************
* NAME: mem_task_init
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*----------------------------------------------------------------------------
* PURPOSE: 
*   Memory task initialization
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void mem_task_init (void)
{
  gl_memory = MEM_CHIP;                     /* select on-board memory */
  mem_state = MEM_INIT;
  mem_force_mmc = FALSE;
}


/*F**************************************************************************
* NAME: mem_task
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*----------------------------------------------------------------------------
* PURPOSE: 
*   Memory management task
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*   STATES:
*   MEM_INIT            memories initialization
*   MEM_CHIP_INIT       on-chip memory selection
*   MEM_CHIP_IDLE       on-chip memory is selected
*   MEM_MMC1_INIT       MMC1 card initialization
*   MEM_MMC1_ACQ        MMC1 card acquisition
*   MEM_MMC1_SETUP      MMC1 card setup
*   MEM_MMC1_IDLE       MMC1 card selected
*   MEM_MMC2_INIT       MMC2 card initialization
*   MEM_MMC2_ACQ        MMC2 card acquisition
*   MEM_MMC2_SETUP      MMC2 card setup
*   MEM_MMC2_IDLE       MMC2 card selected
*   MEM_MMC1_ERROR      MMC1 card error
*   MEM_MMC2_ERROR      MMC2 card error
*   MEM_CHIP_ERR_FMT    on-chip memory not formated
*   MEM_MMC1_ERR_FMT    MMC1 card not formated
*   MEM_MMC2_ERR_FMT    MMC2 card not formated
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void mem_task (void)
{
  switch (mem_state)
  {
    case MEM_INIT:
    { 
      nf_init();                /* memory initialization */
      mem_state = MEM_CHIP_INIT;
      break;
    }

    case MEM_CHIP_INIT:
    {
      gl_memory = MEM_CHIP;                 /* select on-board memory */
      print_mem(SYMB_CHIP);                 /* print on-board symbol */
      if (File_mount() == OK)               /* mount file system */
      {
        mem_state = MEM_CHIP_IDLE;
      }
      else
      {
        mem_state = MEM_CHIP_ERR_FMT;       /* memory not formatted */
      }
      break;
    }

    case MEM_CHIP_IDLE:
    {
      break;
    }

    case MEM_CHIP_ERR_FMT:
    {
      break;
    }
  }
}


/*F**************************************************************************
* NAME: mem_status
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*   memory status:  MEM_BUSY:   install in progress
*                   MEM_READY:  install done
*                   MEM_FORMAT: install done but memory not formated
*----------------------------------------------------------------------------
* PURPOSE: 
*   Return memory status
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
Byte mem_status (void)
{
  if ((mem_state == MEM_CHIP_IDLE) ||
      (mem_state == MEM_MMC1_IDLE) ||
      (mem_state == MEM_MMC2_IDLE))
  {
    return (MEM_READY);
  }
  if ((mem_state == MEM_CHIP_ERR_FMT) ||
      (mem_state == MEM_MMC1_ERR_FMT) ||
      (mem_state == MEM_MMC2_ERR_FMT))
  {
    return (MEM_FORMAT);
  }
  else
  {
    return (MEM_BUSY);
  }
}


/*F**************************************************************************
* NAME: mem_check_card
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*   OK: card present or on-board memory
*   KO: card not present
*----------------------------------------------------------------------------
* PURPOSE: 
*   Start card status checking
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
bit mem_check_card (void)
{
      return OK;
}


/*F**************************************************************************
* NAME: mem_select_next
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*----------------------------------------------------------------------------
* PURPOSE:
*   Select next on-board or card memory
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void mem_select_next (void)
{
  switch (mem_state)
  {
    case MEM_CHIP_IDLE:
    case MEM_CHIP_ERR_FMT:
    {
      mem_state = MEM_MMC1_INIT;
      break;
    }
    case MEM_MMC1_IDLE:
    case MEM_MMC1_ERR_FMT:
    {
      mem_state = MEM_MMC2_INIT;
      break;
    }
    case MEM_MMC2_IDLE:
    case MEM_MMC2_ERR_FMT:
    {
      mem_state = MEM_CHIP_INIT;
      break;
    }
  }
}


/*F**************************************************************************
* NAME: mem_select_format
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*   File system mount status
*----------------------------------------------------------------------------
* PURPOSE:
*   Re-mount memory after format or mass storage update 
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
bit mem_select_format (void)
{
  gl_mem_tick = MEM_WRITE_TIME;

  switch (mem_state)
  {
    case MEM_CHIP_ERR_FMT:
    case MEM_CHIP_IDLE:
    {
      while (gl_mem_tick != MEM_TIME_OUT)
      {
        if (File_mount() == OK)             /* check if format ok */
        {
          mem_state = MEM_CHIP_IDLE;
          return OK;
        }
      }
      return KO;
    }

    case MEM_MMC1_ERR_FMT:
    case MEM_MMC1_IDLE:
    {
      while (gl_mem_tick != MEM_TIME_OUT)
      {
        if (File_mount() == OK)             /* check if format ok */
        {
          mem_state = MEM_MMC1_IDLE;
          return OK;
        }
      }
      return KO;
    }

    case MEM_MMC2_ERR_FMT:
    case MEM_MMC2_IDLE:
    {
      while (gl_mem_tick != MEM_TIME_OUT)
      {
        if (File_mount() == OK)             /* check if format ok */
        {
          mem_state = MEM_MMC2_IDLE;
          return OK;
        }
      }
      return KO;
    }

    default:
    {
      return KO;
    }
  }
}