mem_task.c

ATMEL全套MP3设计资料

/*C**************************************************************************
* $RCSfile: mem_task.c,v $
*----------------------------------------------------------------------------
* Copyright (c) 2002 Atmel.
*----------------------------------------------------------------------------
* RELEASE:      $Name: DEMO_FAT_1_9_9 $      
* REVISION:     $Revision: 1.8 $     
* FILE_CVSID:   $Id: mem_task.c,v 1.8 2002/06/07 15:46:17 ffosse Exp $       
*----------------------------------------------------------------------------
* 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 "..\display\disp.h"                /* display definition */
#include "..\file\file.h"                   /* file definition */
#include "..\..\..\..\lib_mem\df\df.h"      /* dataflash definition */
#include "..\..\..\..\lib_mem\mmc\mmc.h"    /* mmc 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 */

static  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_DF;                       /* 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_DF_INIT         DF memory selection
*   MEM_DF_IDLE         DF memory is selected
*   MEM_MMC1_ACQ        MMC1 card acquisition
*   MEM_MMC1_SETUP      MMC1 card setup
*   MEM_MMC1_IDLE       MMC1 card selected
*   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_DF_ERR_FMT      DF not formated
*   MEM_MMC1_ERR_FMT    MMC1 card not formated
*   MEM_MMC2_ERR_FMT    MMC2 card not formated
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void mem_task (void)
{
Byte    func_state;

  switch (mem_state)
  {
    case MEM_INIT:
    {
      mmc_init();                           /* memory initialization */
      if ((mem_state = df_init()) != 0)     /* memory initialization */
      {
        print_screen(FATAL_DF_SCREEN);
        print_decim(mem_state, TRUE);       /* display faulty DF number */
        while (1);                          /* stop if bad memory */
      }
      mem_state = MEM_DF_INIT;
      break;
    }

    case MEM_DF_INIT:
    {
      Mmc_disable();
      df_init_mem();
      gl_memory = MEM_DF;                   /* select on-board memory */
      print_mem(SYMB_DF);                   /* print on-board symbol */
      if (File_mount() == OK)               /* mount file system */
      {
        mem_state = MEM_DF_IDLE;
      }
      else
      {
        mem_state = MEM_DF_ERR_FMT;         /* memory not formatted */
      }
      break;
    }

    case MEM_DF_IDLE:
    {
      break;
    }

    case MEM_MMC1_INIT:
    {
      /* reset card stack */
      mmc_init_stack();
      gl_memory = MEM_MMC;
      mem_state = MEM_MMC1_ACQ;
      gl_mem_tick = MEM_FUNCT_TIME;         /* init delay timer */
      break;
    }

    case MEM_MMC1_ACQ:
    {
      if (gl_mem_tick >= MEM_DELAY_TIME)
      {
        /* send operating conditions */
        func_state = mmc_single_acq();
        if (func_state == MMC_ERROR)
        {
          mem_state = MEM_MMC1_ERROR;
        }
        else
        {
          if (func_state == MMC_END)        /* end of execution */
          { /* MMC1 CSD is available now */
            if (!mmc_init_csd())            /* init & check card validity */
            {
              mem_state = MEM_MMC1_ERROR;
            }
            else
            {
              mem_state = MEM_MMC1_SETUP;
            }
          }
          gl_mem_tick = MEM_FUNCT_TIME;     /* init delay timer */
        }
      }
      break;
    }

    case MEM_MMC1_SETUP: 
    {
      if (gl_mem_tick >= MEM_DELAY_TIME)
      { /* go to transfer state */
        func_state = mmc_setup_card(MMC_CARD1);
        if (func_state == MMC_ERROR)
        {
          mem_state = MEM_MMC1_ERROR;
        }
        else
        {
          if (func_state == MMC_END)        /* end of execution */
          {
            gl_memory = MEM_MMC;
            if (File_mount() == OK)         /* mount file system */
            {
              mem_state = MEM_MMC1_IDLE;
            }
            else
            {
              mem_state = MEM_MMC1_ERR_FMT; /* card not formatted */
            }
            print_mem(SYMB_MMC1);           /* print MMC1 symbol */
          }
          gl_mem_tick = MEM_FUNCT_TIME;     /* init delay timer */
        }
      }
      break;
    }

    case MEM_MMC1_IDLE:
    {
      break;
    }

    case MEM_MMC2_STACK_INIT:
    {
      /* reset card stack */
      mmc_init_stack();
      gl_memory = MEM_MMC;
      mem_state = MEM_MMC2_MMC1_ACQ;
      gl_mem_tick = MEM_FUNCT_TIME;         /* init delay timer */
      break;
    }

    case MEM_MMC2_MMC1_ACQ:
    {
      if (gl_mem_tick >= MEM_DELAY_TIME)
      {
        /* send operating conditions */
        func_state = mmc_single_acq();
        if (func_state == MMC_ERROR)
        {
          mem_state = MEM_MMC2_ERROR;
        }
        else
        {
          if (func_state == MMC_END)        /* end of execution */
          {
            mem_state = MEM_MMC2_MMC1_SETUP;
          }
          gl_mem_tick = MEM_FUNCT_TIME;     /* init delay timer */
        }
      }
      break;
    }

    case MEM_MMC2_MMC1_SETUP: 
    {
      if (gl_mem_tick >= MEM_DELAY_TIME)
      {
        func_state = mmc_setup_card(MMC_CARD1);
        if (func_state == MMC_ERROR)
        {
          mem_state = MEM_MMC2_ERROR;
        }
        else
        {
          if (func_state == MMC_END)        /* end of execution */
          {
            mem_state = MEM_MMC2_ACQ;
          }
          gl_mem_tick = MEM_FUNCT_TIME;     /* init delay timer */
        }
      }
      break;
    }

    case MEM_MMC2_INIT:
    {
      mmc_init_next();                      /* new acquisition */
      mem_state = MEM_MMC2_ACQ;
      gl_mem_tick = MEM_FUNCT_TIME;         /* init delay timer */
      break;
    }

    case MEM_MMC2_ACQ:
    {
      if (gl_mem_tick >= MEM_DELAY_TIME)
      {
        /* send operating conditions */
        func_state = mmc_update_acq();
        if (func_state == MMC_ERROR)
        {
          mem_state = MEM_MMC2_ERROR;
        }
        else
        {
          if (func_state == MMC_END)        /* end of execution */
          { /* MMC2 CSD is available now */
            if (!mmc_init_csd())            /* init & check card validity */
            {
              mem_state = MEM_MMC2_ERROR;
            }
            else
            {
              mem_state = MEM_MMC2_SETUP;
            }
          }
          gl_mem_tick = MEM_FUNCT_TIME;     /* init delay timer */
        }
      }
      break;
    }

    case MEM_MMC2_SETUP: 
    {