/*C**************************************************************************
* NAME:         mem_task.c
*----------------------------------------------------------------------------
* Copyright (c) 2003 Atmel.
*----------------------------------------------------------------------------
* RELEASE:      snd1c-refd-nf-4_0_3      
* REVISION:     1.23     
*----------------------------------------------------------------------------
* 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  bdata   bit     fs_memory;          /* selected file system */
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)
{
  mem_state = MEM_INIT;
  mem_force_mmc = FALSE;
  #if MEM_CHIP_TYPE != CHIP_NONE
    gl_memory = MEM_CHIP;             /* select on-board memory */
  #else
    gl_memory = MEM_CARD;             /* select card memory */
  #endif
  #if (MEM_CARD_TYPE != CARD_NONE) && (CARD_SOCKET_NB == 2)
    if (Card_get_socket() == MEM_CARD_2)
    {
      Card_select_next();   
    }
  #endif
}


/*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_CHIP_ERR_FMT    on-chip memory not formated
*   MEM_CARD_INIT       card initialization
*   MEM_CARD_IDLE       card selected
*   MEM_CARD_ERR        card error
*   MEM_CARD_ERR_FMT    card not formated
*   MEM_CARD_NO_CARD    no card insert
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void mem_task (void)
{
Byte state;

  switch (mem_state)
  {
    case MEM_INIT:
    {
      #if MEM_CHIP_TYPE != CHIP_NONE          /* if chip defined */
        if (Hard_chip_init() == OK)           /* if init chip OK */
        {
          mem_state = MEM_CHIP_INIT;          /* install chip */
        }
        #if MEM_CARD_TYPE != CARD_NONE        /* if card defined */
          if (Hard_card_init() == KO)         /* init card */
          {
            if (mem_state == MEM_INIT)          /* if chip and card init failed */
            {
              print_screen(FATAL_CHIP_SCREEN);    /* fatal error */
              while(1);
            }
          }
          else
          {
            if (mem_state == MEM_INIT)
            {
              mem_state = MEM_CARD_INIT;         /* install card */
            }
          }
        #else
          if (mem_state == MEM_INIT)          /* if chip init failed and no card defined */
          {
            print_screen(FATAL_CHIP_SCREEN);    /* fatal error */
            while(1);
          }
        #endif
      #else
        if (Hard_card_init() == OK)         /* init card */
        {
          mem_state = MEM_CARD_INIT;
        }
      #endif
      break;
    }

    case MEM_CHIP_INIT:
    {
      #if (MEM_CHIP_TYPE == CHIP_NONE)
        mem_state = MEM_CARD_INIT;
        break;
      #else
        Hard_card_uninstall();
        state = Hard_chip_install();
        if (state == MEM_OK)
        {
          gl_memory = MEM_CHIP;                 /* select on-board memory */
          print_mem(SYMB_CHIP);                 /* print on-board symbol */
          #if (MEM_CHIP_FS == FS_FAT_32) || (MEM_CHIP_FS == FS_FAT_12_16)
            fs_memory = FS_MEM_FAT;
          #else
            fs_memory = FS_MEM_ISO;
          #endif
          if (File_mount() == OK)               /* mount file system */
          {
            mem_state = MEM_CHIP_IDLE;
          }
          else
          {
            mem_state = MEM_CHIP_ERR_FMT;       /* memory not formatted */
          }
        }
        break;
      #endif
    }

    case MEM_CHIP_IDLE:
    {
      break;
    }

    case MEM_CHIP_ERR_FMT:
    {
      break;
    }

    case MEM_CARD_INIT:
    {
      #if (MEM_CARD_TYPE == CARD_NONE)
        mem_state = MEM_CHIP_INIT;
        break;
      #else
        state = Hard_card_install(); /* get state of card install */
        if (state == MEM_OK)  /* if card installation OK */
        {
          if (Card_check_presence() == OK) /* always check if a card is present */
          {
            gl_memory = MEM_CARD; /* select card for interface */
            #if CARD_SOCKET_NB == 2    /* if project define two card sockets */
              if (Card_get_socket() == MEM_CARD_1)
              {
                print_mem(SYMB_CARD1);  /* print CARD1 symbol */
              }
              else
              {
                print_mem(SYMB_CARD2);  /* print CARD2 symbol */
              }
            #else                       /* if project define only one socket */
              print_mem(SYMB_CARD);     /* print CARD symbol */
            #endif

            #if (MEM_CARD_FS == FS_FAT_32) || (MEM_CARD_FS == FS_FAT_12_16)
              fs_memory = FS_MEM_FAT;
            #else
              fs_memory = FS_MEM_ISO;
            #endif

            if (File_mount() == OK)     /* Install file system */
            {
              mem_state = MEM_CARD_IDLE;/* if fs OK set card as idle */
            }
            else
            {
              mem_state = MEM_CARD_ERR_FMT;/* fs is not OK */
            }
          }
          else
          {
            mem_state = MEM_CARD_NO_CARD; /* no card in socket */
          }
        }
        else
        {
          if (state == MEM_KO)
          {
            #if CARD_SOCKET_NB == 2              /* if 2 card sources defines */
              if (Card_get_socket() == MEM_CARD_2)
              {
                mem_state = MEM_CHIP_INIT;  /* 2nd card socket -> select on board memory */
              }            
              Card_select_next();                  /* select next card source */
            #else
              #if MEM_CHIP_TYPE != CHIP_NONE
                mem_state = MEM_CHIP_INIT;    /* select on board memory */
              #else
                mem_state = MEM_CARD_NO_CARD;
              #endif
            #endif
          }
        }
        break;
      #endif
    }

    case MEM_CARD_IDLE:
    {
      break;
    }

    case MEM_CARD_ERR:
    {
      #if (MEM_CARD_TYPE != CARD_NONE)
        #if (CARD_SOCKET_NB == 2)   /* if 2x card socket */
          if (mem_force_mmc)
          {
            mem_state = MEM_CARD_INIT;
          }
          else
          {
            Hard_card_uninstall();
            if (Card_get_socket() == MEM_CARD_1)
            {
              mem_state = MEM_CARD_INIT;
            }
            else
            {
              mem_state = MEM_CHIP_INIT;
            }
            Card_select_next();
          }
        #endif
      #endif
      
      break;
    }

    case MEM_CARD_ERR_FMT:
    {
      break;
    }

    case MEM_CARD_NO_CARD:          /* medium is not present or tray (CDR) is open */
    {